设计模式之——享元模式

1 享元模式的定义

享元模式：使用共享对象可有效地支持大量细粒度的对象。享元模式是池技术的重要实现方式。
享元模式的定义提出了两个要求：

• 细粒度的对象
• 共享对象

细粒度的对象数量众多并且性质相近，就可以将这些对象信息分为两个部分：内部状态(intrinsic)和外部状态(extrinsic)。

• 内部状态
  内部状态是对象可以共享出来的信息，存储在享元对象内部并且不会随环境改变而改变。内部状态可以作为一个对象的动态附加信息，不必直接存储于具体某个对象中，属于可共享的而部分。

• 外部状态
  外部状态是对象的特有标记，随环境改变而改变，是对象不可以共享的状态。

享元模式的通用类图：

享元模式通用类图

• Flyweight——抽象享元角色
  一个产品的抽象类，同时定义出对象的外部状态和内部转台的接口或实现。

• ConcreteFlyweight——具体享元角色
  具体的一个产品类，实现抽象角色定义的业务。该角色中内部状态处理与环境无关，不应该也不允许出现一个操作改变了内部状态，同时修改了外部状态。

• UnsharedConcreteFlyweight——不可共享的享元角色
  不存在外部状态或安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。

• FlyweightFactory——享元工厂
  享元工厂，职责简单，就是作为一个池容器，同时提供从池中获取对象的方法。

享元模式的目的在于运用共享技术，使得一些细粒度的对象可以共享。多使用细粒度的对象，便于重用和重构。

2 享元模式通用示例

1. 抽象享元角色
   抽象享元一般为抽象类，但是在实际项目中，一般是一个实现类。抽象享元角色描述一类事物的方法。在抽象角色中，一般要把外部状态和内部状态(可以没有内部状态而只有行为)定义出来，避免子类的随意扩展。

@Slf4j
public abstract class Flyweight {
    /**
     * 内部状态
     */
    private String intrinsic;
    /**
     * 外部状态
     */
    protected final String extrinsic;

    /**
     * 构造函数，必须接收外部状态
     */
    public Flyweight(String extrinsic) {
        this.extrinsic = extrinsic;
    }

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

    /**
     * 内部状态的getter
     *
     * @return
     */
    public String getIntrinsic() {
        return intrinsic;
    }

    /**
     * 内部状态的setter
     *
     * @param intrinsic
     */
    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }
}

2. 具体享元角色
   具体享元角色实现自己具体的业务，然后接受外部状态，以便内部业务逻辑对外部状态的依赖。在抽象享元中对外部状态加上了final关键字，防止意外修改外部状态。
   注意：在程序开发中，确认只需要一次赋值的属性设置为final类型，避免意外修改导致逻辑混乱，特别是Session(Context)级的常量或变量。

@Slf4j
public class ConcreteFlyweightA extends Flyweight {
    /**
     * 构造函数，必须接收外部状态
     *
     * @param extrinsic 外部状态
     */
    public ConcreteFlyweightA(String extrinsic) {
        super(extrinsic);
    }

    /**
     * 根据外部状态，进行逻辑处理
     */
    @Override
    public void operate() {
        log.info("享元角色{}的外部业务逻辑处理。extrinsic={}", this.getClass().getSimpleName(), extrinsic);
    }
}

@Slf4j
public class ConcreteFlyweightB extends Flyweight {
    /**
     * 构造函数，必须接收外部状态
     *
     * @param extrinsic 外部状态
     */
    public ConcreteFlyweightB(String extrinsic) {
        super(extrinsic);
    }

    /**
     * 根据外部状态，进行逻辑处理
     */
    @Override
    public void operate() {
        log.info("享元角色{}的外部业务逻辑处理。extrinsic={}", this.getClass().getSimpleName(), extrinsic);
    }
}

3. 享元工厂
   享元工厂，职责简单，就是作为一个池容器，同时提供从池中获取对象的方法。

@Slf4j
public class FlyweightFactory {
    /**
     * 池容器
     */
    private static Map pool = new HashMap<>();

    /**
     * 享元工厂
     */
    public static Flyweight getFlyweightA(String extrinsic) {
        //需要返回的对象
        Flyweight flyweight = null;
        //如果池中存在享元对象，直接返回；否则，创建对象并放入池中，然后返回
        if (pool.containsKey(extrinsic)) {
            flyweight = pool.get(extrinsic);
        } else {
            flyweight = new ConcreteFlyweightA(extrinsic);
            pool.put(extrinsic, flyweight);
        }
        return flyweight;
    }
    
}

3 享元模式的优缺点

1. 优点
   享元模式可以减少应用程序创建的对象，降低程序内存的占用，提高程序性能。
2. 缺点

• 享元模式提高了系统复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特性，不应该随着内部状态改变而改变，否则会导致系统逻辑混乱。
• 在多线程的场景中，如果享元过少，每个线程都修改相同享元对象的属性，就会出现逻辑错误。

4 享元模式应用场景

1. 系统中存在大量的相似对象。
2. 细粒度的对象都具备较近的外部状态，而且内部状态与环境无关（对象没有特定身份）。
3. 需要缓冲池的场景。

建议

• 在享元模式中，尽量使用Java基本类型作为外部状态，以此来提高运行效率。
• 虽然使用享元模式可以实现对象池，但是这两者还是有区别的。
  对象池：着重对象的复用，池中的对象是可替换的，从池中获得A对象和B对象对客户端来说是完全相同的，主要解决复用问题，比如线程池。
  享元模式：主要解决对象的共享，关注重点是如何建立多个可贡献的细粒度对象。

参考

1. 设计模式之禅