Java设计模式（十）享元模式

享元模式

定义

又称为轻量级模式，是对象池的一种实现。类似于线程池，线程池可以避免不停地创建机额注销多个对线，消耗性能，提供了减少对象数量从而改善应用所需的对象结构的方式。

宗旨：共享细粒度对象，将多个对象的访问集中起来。属于结构型模式。

享元模式把一个对象的状态分为内部状态和外部状态，内部状态即是不变的，外部状态是变化的；然后通过共享不变的部分，达到减少对象数量并节约内存的目的。

享元模式的本质是缓存共享对象，降低内存消耗。

角色

1. 抽象享元角色（Flyweight）：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现；
2. 具体享元角色（ConcreteFlyweight）：实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不能出现会有一个操作改变内部状态，同时修改外部状态；
3. 享元工厂（FlyweightFactory）：负责管理享元对象池和创建享元对象。

适用场景

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提过给多出需要使用的地方，避免大龄统一对象的多次创建，消耗大量内存空间。
享元模式其实就是工厂模式的一种改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法生成对象的，只不过享元模式中为工厂方法增加了缓存这一个功能。

1. 常常应用于系统底层的开发，以便解决系统的性能问题。
2. 系统中有大量的对象，需要缓冲池的场景。

通用写法

public interface IFlyweight {
    void operation(String extrinsicState);
}

public class ConcreteFlyweight implements IFlyweight {

    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println("Object address: " + System.identityHashCode(this));
        System.out.println("IntrinsicState: " + this.intrinsicState);
        System.out.println("ExtrinsicState: " + extrinsicState);
    }
}

public class FlyweightFactory {

    private static Map<String, IFlyweight> pool = new HashMap<String, IFlyweight>();

    public static IFlyweight getFlyweight(String intrinsicState) {
        if (!pool.containsKey(intrinsicState)) {
            IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
            pool.put(intrinsicState, flyweight);
        }
        return pool.get(intrinsicState);
    }
}

public class test {
    public static void main(String[] args) {
        IFlyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
        IFlyweight flyweight2 = FlyweightFactory.getFlyweight("bb");
        flyweight1.operation("a");
        flyweight2.operation("b");
    }
}

代码演示

public interface ITicket {
    void showInfo(String bunk);
}

public class TrainTicket implements ITicket{

    private String from;

    private String to;

    private int price;

    public TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public void showInfo(String bunk) {
        this.price = new Random().nextInt(100);
        System.out.println(String.format("%s->%s：%s价格：%s 元", this.from, this.to, bunk, this.price));
    }
}

public class TicketFactory {

    private static Map<String, ITicket> sTicketPool = new HashMap<String, ITicket>();

    public static ITicket queryTicket(String from, String to){
        String key = from + "->" + to;
        if (sTicketPool.containsKey(key)){
            System.out.println("使用缓存：" + key);
            return TicketFactory.sTicketPool.get(key);
        }
        System.out.println("首次查询，创建对象: " + key);
        ITicket ticket = new TrainTicket(from, to);
        TicketFactory.sTicketPool.put(key, ticket);
        return ticket;
    }
}

在演示代码中可以看出享元模式的缓存写法与单例模式的注册式单例模式在结构上非常相似，范式享元模式的重点在结构上，而不是创建对象上。

享元模式在源码中的应用

String中的享元模式

Java中将String类定义为final，JVM中字符串一般保存在字符串常量池中，Java会确保一个字符串在常量池中只有一个拷贝（字符串常量池位于堆中）

享元模式的内部状态与外部状态

享元模式的定义为我们提出了两个要求：细粒度和共享对象，因为要求细粒度多余不可避免地会使对象数量多且性质相近，此时我们将这些对象的信息分为两个部分，内部状态和外部状态。
内部状态是指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；外部状态指对象得以依赖一个标记，是随环境变化二改变的，不可共享的状态。例如，连接池中的连接对象，保存的用户名等信息再创建对象的时候就创建好了，不会随环境的改变而改变，这些是内部状态。而每一个连接要回收时，我们需要给它标记可用状态，这些为外部状态。

优点

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

缺点

1. 关乎内、外部状态，关注线程安全。
2. 使系统、程序的逻辑复杂化。