设计模式 _第十六招式_享元模式

一、定义

享元模式（Flyweight Pattern）是池技术的重要实现方式其定义如下：使用共享对象可以有效地支持大量的细粒度的对象。

享元模式的定义为我们提出列两个要求：细粒度对象和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，那怎么规避呢 ？就是享元模式提供的共享技术。

要求细粒度对象，则会导致对象的数量多且属性都非常相似，为了抽取相同的属性， 可以将对象内容分为两个部分：内部状态（instrinsic）与外部状态（extrinsic）。

• 内部状态

  内部状态是对象可共享出来的信息。存储在享元对象内部并且不会随着环境改变而改变，他们可以作为一个对象的动态附件信息， 不直接保存在对象内部，如一个学生类中的 所属学校信息等。

• 外部状态

  外部状态是对象依赖的一些属性，是随环境改变而改变的、不可以共享的状态，如一个用户类的 创建时间、姓名等。

二、代码演示

2.1 通用类图

2.2 角色说明

• Flyweight–抽象享元角色

  简单说是一个产品的抽象类，同时定义了对象的外部状态和内部状态的接口或实现。

  -ConcreteFlyweight–具体享元角色

  具体的一个产品类，该类中内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态。

• unsharedConcreteFlyweight–不可共享的享元角色

  不存在外部状态或线程安全不能够用共享技术的对象，该对象一般不会出现在享元工厂中。

• FlyweightFactory–享元工厂

  职责非常简单，就是构建一个池容器，同时提供从池中获取对象的方法。

2.3 抽象享元角色

抽象享元角色一般为抽象类，在实际项目中，一般是一个实现类，它是描述一类事物的方法。抽象角色中，一般需要把外部状态和内部状态定义出来，避免子类的随意扩展。

package com.design.flyweiht.pattern;

/**
 * @description 抽象享元对象
 * @date: 2019/9/28 17:24
 * @version: v 0.1
 */
public abstract class Flyweight {
    //内部状态
    private String intrinsic;
    //外部状态
    protected final String extrinsic;

    public Flyweight(String _extrinsic) {
        this.extrinsic = _extrinsic;
    }

    //定义业务操作
    public abstract void operate();

    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }

    public String getExtrinsic() {
        return extrinsic;
    }
}

           

2.4 具体享元角色

实现自己的业务逻辑，然后接收外部状态，以便内部业务逻辑对外部状态的依赖。

package com.design.flyweiht.pattern;

/**
 * @description 具体享元对象
 * @date: 2019/9/28 17:31
 * @version: v 0.1
 */
public class ConcreteFlyweight1 extends Flyweight {
    public ConcreteFlyweight1(String _extrinsic) {
        super(_extrinsic);
    }

    @Override
    public void operate() {
        System.out.println("ConcreteFlyweight1 operate");
    }
}

           

2.5 享元工厂

package com.design.flyweiht.pattern;

import java.util.HashMap;

/**
 * @description 享元工厂
 * @date: 2019/9/28 17:47
 * @version: v 0.1
 */
public class FlyweightFactory {
    //定义一个容器
    private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();

    public static Flyweight getFlyweight(String extriansic) {
        //返回需要的对象
        Flyweight flyweight = null;
        if (pool.containsKey(extriansic)) {
            flyweight = pool.get(extriansic);
            System.out.println("FlyweightFactory  :" + extriansic + ":  come from pool");
        } else {
            //根据外部状态创建享元对象
            flyweight = new ConcreteFlyweight1(extriansic);
            //放到池中
            pool.put(extriansic, flyweight);
            System.out.println("FlyweightFactory  :" + extriansic + ":  not come from pool");
        }
        return flyweight;
    }
}


           

2.6 验证场景类

package com.design.flyweiht.pattern;

/**
 * @description TODO
 * @date: 2019/9/28 17:57
 * @version: v 0.1
 */
public class Client {
    public  static  void  main(String args[]){
        String extriansic= "tester";
        Flyweight  flyweight1 = FlyweightFactory.getFlyweight(extriansic);
        flyweight1.operate();
        Flyweight  flyweight2 = FlyweightFactory.getFlyweight(extriansic);
        flyweight2.operate();
    }
}

           

2.7 运行结果

FlyweightFactory  :tester:  not come from pool
ConcreteFlyweight1 operate
FlyweightFactory  :tester:  come from pool
ConcreteFlyweight1 operate
           

三、优点

享元模式是一个非常简单的模式，可以大大减少应用程序创建的对象，降低程序内存占用，增加程序的性能；

四、缺点

由于需要区分内部状态和外部状态，而且外部状态是固化的，可能导致系统复杂性增加。

五、应用场景

• 系统中存在大量的相似对象。
• 细粒度的对象中外部状态相似，且内部状态与环境无关。
• 需要缓冲池的场景。

六、注意事项