设计模式之享元模式

享元模式（Flyweight）：使用共享对象可有效的支持大量的细粒度的对象。

享元模式的宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。它把对象的信息分为两个部分：内部状态和外部状态。

• 内部状态：指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变。
• 外部状态：指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。

享元模式的应用很常见，池技术就是享元模式的应用，例如数据库连接池、缓冲池、String池等。

结构

享元模式的主要角色组成：

• 抽象享元角色(Flyweight)：所有具体享元类的超类或接口，通过这个接口，Flyweight可以接受并作用于外部状态。
• 具体享元角色(ConcreteFlyweight)：指定内部状态，为内部状态增加存储空间。
• 非共享具体享元角色(UnsharedConcreteFlyweight)：指出那些不需要共享的Flyweight子类。
• 享元工厂角色(FlyweightFactory)：用来创建并管理Flyweight对象，主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或创建一个实例。

优缺点

优点：

• 减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率。
• 减少内存之外的其他资源占用。

缺点：

• 享元的对象无法拥有独立的行为。
• 关注内/外部状态、关注线程安全问题。
• 使系统、程序的逻辑复杂化。

代码实现

抽象享元角色(Flyweight)

public abstract class Flyweight {

    //内部状态
    public String intrinsic;
    //外部状态
    protected final String extrinsic;
    
    //要求享元角色必须接受外部状态
    public Flyweight(String extrinsic) {
        this.extrinsic = extrinsic;
    }
    
    //定义业务操作
    public abstract void operate(int extrinsic);

    public String getIntrinsic() {
        return intrinsic;
    }

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

}

具体享元角色(ConcreteFlyweight)

public class ConcreteFlyweight extends Flyweight {

    //接受外部状态
    public ConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    //根据外部状态进行逻辑处理
    @Override
    public void operate(int extrinsic) {
        System.out.println("具体Flyweight:" + extrinsic);
    }

}

非共享具体享元角色(UnsharedConcreteFlyweight)

public class UnsharedConcreteFlyweight extends Flyweight {

    public UnsharedConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate(int extrinsic) {
        System.out.println("不共享的具体Flyweight:" + extrinsic);
    }

}

享元工厂角色(FlyweightFactory)

public class FlyweightFactory {

    //定义一个池容器
    private static HashMap<String, Flyweight> pool = new HashMap<>();
    
    //享元工厂
    public static Flyweight getFlyweight(String extrinsic) {
        Flyweight flyweight = null;
        
        if(pool.containsKey(extrinsic)) {    //池中有该对象
            flyweight = pool.get(extrinsic);
            System.out.print("已有 " + extrinsic + " 直接从池中取---->");
        } else {
            //根据外部状态创建享元对象
            flyweight = new ConcreteFlyweight(extrinsic);
            //放入池中
            pool.put(extrinsic, flyweight);
            System.out.print("创建 " + extrinsic + " 并从池中取出---->");
        }
        
        return flyweight;
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        int extrinsic = 22;
        
        Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
        flyweightX.operate(++ extrinsic);
        
        Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
        flyweightY.operate(++ extrinsic);
        
        Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
        flyweightZ.operate(++ extrinsic);
        
        Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
        flyweightReX.operate(++ extrinsic);
        
        Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
        unsharedFlyweight.operate(++ extrinsic);
    } 
}

输出结果：