设计模式-享元模式

享元模式(Flyweight Pattern)：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

享元模式从字面上翻译是“蝇量级模式”，其实并不太好理解。这个模式的作用就是在一个系统当中有很多很多的对象，而这些对象很相似，有细微地方不同，单数数量太大，影响系统性能，为了避免系统中出现大量相同或相似的对象，同时又不影响客户端程序通过面向对象的方式对这些对象进行操作，享元模式横空出世。

好比一个系统里面的字符，有非常之多，每个字符在显示的时候有的颜色不一样，有的大小不一样，有的字体不一样，享元模式通过共享技术实现相同或相似对象的重用，在逻辑上每一个出现的字符都有一个对象与之对应，然而在物理上它们却共享同一个享元对象，这个对象可以出现在一个字符串的不同地方，相同的字符对象都指向同一个实例。而享元模式里面一个重要的地方是享元池，里面装满了各种享元对象。这里可以看出享元模式的“享”是共享，“元”代表公共对象的最原始的状态。

先来看下享元模式的类图：

• Flyweight（抽象享元类）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
• ConcreteFlyweight（具体享元类）：它实现了抽象享元类，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
• UnsharedConcreteFlyweight（非共享具体享元类）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
• FlyweightFactory（享元工厂类）：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，享元工厂提供一个存储在享元池中已创建的实例或者创建一个新的实例（如果不存在的话），返回新创建的实例并将其存储在享元池中。

代码实现下：
享元模式的抽象接口

public abstract class Flyweight {
    public abstract void operation(String state);
}

具体的享元类

public class ConcreteFlyweight extends Flyweight{

    private Character intrinsicState=null;
    
    //构造函数，设置内部状态
    public ConcreteFlyweight(Character intrinsicState) {
        this.intrinsicState=intrinsicState;
    }
    
    //外部状态作为参数进入方法
    @Override
    public void operation(String extrinsicState) {
        System.out.println("内部状态是："+intrinsicState);
        System.out.println("外部状态是："+ extrinsicState);
    }

}

不需要共享的情况，有时候就是需要在内存里面新增一个

public class UnsharedConcreteFlyweight extends Flyweight{

    @Override
    public void operation(String extrinsicstate) {
        System.out.println("不共享的具体状态:"+extrinsicstate);
    }
}

接下来是享元模式的工厂，负责整合这些“元”,由一个 Hash 表进行管理，在构造的时候没有把不共享的“元”增加进去，当然也可以进行判断。

public class FlyweightFactory {

    private HashMap<String,Flyweight> characters=new HashMap<String,Flyweight>();
    public FlyweightFactory() {
        characters.put("A", new ConcreteFlyweight('a'));
        characters.put("B", new ConcreteFlyweight('b'));
        characters.put("C", new ConcreteFlyweight('c'));
    }
    
    public Flyweight getFlyweight(String key){
        return characters.get(key);
    }
    
}

Client 端将通过工厂从里面获取，工厂一般可以做成单例，确保系统范围只有一个享元工厂。

public class Client {

    public static void main(String[] args) {
        FlyweightFactory factory=new FlyweightFactory();
        Flyweight a1=factory.getFlyweight("A");
        a1.operation("StateA1");
        
        Flyweight a2=factory.getFlyweight("A");
        a2.operation("StateA2");
        
        Flyweight b=factory.getFlyweight("B");
        b.operation("StateB");

    }

}

看下结果：

内部状态是：a
外部状态是：StateA1
内部状态是：a
外部状态是：StateA2
内部状态是：b
外部状态是：StateB

扩展：有的时候需要把几个 Flyweight 组合为一个，这就出现了具体复合享元角色，他是有一些单个的享元角色组合而成，提供一个集合进行管理，当然也继承抽象的享元角色，也有 operation()方法，这个方法的唯一参数代表复合对象的外部状态，而且这个外部状态和内部包括的小享元的外部状态一致，内部状态不一定一样。由于内部状态会改变，所以也是不能共享的。

优点和缺点

享元模式的主要优点如下：
(1) 可以极大减少内存中对象的数量，使得相同或相似对象在内存中只保存一份，从而可以节约系统资源，提高系统性能。
(2) 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

享元模式的主要缺点如下：
(1) 享元模式使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
(2) 为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长。

该模式使用频率不高，场合不多，在以下情况下可以考虑使用享元模式：
(1) 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
(2) 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
(3) 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。