设计模式之禅-享元模式

享元模式

例子

报考系统。需要选择考试地点（选择框）、报考地点（选择框）、邮寄地址（输入框），还有其他信息。

做一个很小的改动，增加了一个子类，实现带缓冲池的对象建立，同时在工厂类上增加 了一个容器对象HashMap，保存池中的所有对象。

public class SignInfo {
    private String id;
    private String location;
    private String subject;
    private String postAddress;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getPostAddress() {
        return postAddress;
    }

    public void setPostAddress(String postAddress) {
        this.postAddress = postAddress;
    }
}

public class SignInfo4Pool extends SignInfo{
    private String key;

    public SignInfo4Pool(String key) {
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }
}

public class SignInfoFactory {
    private static HashMap<String, SignInfo> pool = new HashMap<>();

    public static SignInfo getSignInfo(String key) {
        SignInfo result = null;
        if (!pool.containsKey(key)) {
            System.out.println(key + "----建立对象，并放到池中");
            result = new SignInfo4Pool(key);
            pool.put(key, result);
        } else {
            result = pool.get(key);
            System.out.println(key + "---直接从池中取得");
        }
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        // 初始化对象池
        for (int i = 0; i < 4; i++) {
            String subject = "科目"+i;
            // 初始化地址
            for (int j = 0; j < 30; j++) {
                String key = subject+"考试地点"+j;
                SignInfoFactory.getSignInfo(key);
            }
        }
        SignInfo signInfo = SignInfoFactory.getSignInfo("科目1考试地点1");
    }
}

定义

使用共享对象可有效地支持大量的细粒度的对象。
要求细粒度对象，那么不可避免地使得对象数量多且性质相近，那我们就将这些对象的信息分为两个部分：内部状态（intrinsic）与外部状态（extrinsic）。

• 内部状态
  内部状态是对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变， 如我们例子中的id、postAddress等，它们可以作为一个对象的动态附加信息，不必直接储存 在具体某个对象中，属于可以共享的部分。
• 外部状态
  外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态，如 我们例子中的考试科目+考试地点复合字符串，它是一批对象的统一标识，是唯一的一个索引值。
  
• Flyweight——抽象享元角色
  它简单地说就是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。
• ConcreteFlyweight——具体享元角色
  具体的一个产品类，实现抽象角色定义的业务。该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是绝对不允许的。
• unsharedConcreteFlyweight——不可共享的享元角色
  不存在外部状态或者安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。
• FlyweightFactory——享元工厂
  职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。

public abstract class Flyweight {
    // 外部状态
    private final String Extrinsic;
    // 内部状态
    private String intrinsic;

    // 要求享元角色必须接受外部状态
    public Flyweight(String extrinsic) {
        Extrinsic = extrinsic;
    }

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

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

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

public class ConcreteFlyweight1 extends Flyweight{
    // 接受外部状态
    public ConcreteFlyweight1(String extrinsic) {
        super(extrinsic);
    }


    @Override
    public void operate() {

    }


}

public class ConcreteFlyweight2 extends Flyweight{
    // 接受外部状态
    public ConcreteFlyweight2(String extrinsic) {
        super(extrinsic);
    }


    @Override
    public void operate() {

    }
}

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);
        }else{
            flyweight = new ConcreteFlyweight1(Extrinsic);
            pool.put(Extrinsic,flyweight);
        }
        return flyweight;
    }
}

优点

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

缺点

提高了系统复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特性，不应该随内部状态改变而改变，否则导致系统的逻辑混乱。

使用场景

• 系统中存在大量的相似对象。
• 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。
• 需要缓冲池的场景。

扩展

线程安全的问题

当外部状态不够细致，该模式有太大的几率发生线程不安全。设置的享元对象数量太少，导致每个线程都到对 象池中获得对象，然后都去修改其属性，于是就出现一些不和谐数据。我们在使用享元模式时，对象池中的享元对象尽量多，多到足够满足业务为止。

性能平衡

尽量使用Java基本类型作为外部状态。当使用对象作为外部状态，一定要覆写equals和hashCode方法，否则它作为HashMap中的key值是根本没有意义的，只有hashCode值相等，并且equals返回结果为true，两个对象才相等，也只有在这种情 况下才有可能从对象池中查找获得对象。当还是非常简单的享元对象，使用基本类型和String作为外部状态，比使用对象作为外部状态效率提高一倍。并且使用对象还要重写equals方法和hashCode方法，而且执行效率还比较低。（还有当并发流parallelStream时，使用基本类型和String才会使用多核）

注意

虽然可以使用享元模式可以实现对象池，但是这两者还是有比较大的差异，对象池着重在对象的复用上，池中的每个对象是可替换的，从同一个池中获得A对象和B对象对客户端来说是完全相同的，它主要解决复用，而享元模式在主要解决的对象的共享问题，如何建立多个可共享的细粒度对象则是其关注的重点。