结构型模式之享元模式

面向对象技术可以很好的解决一些灵活性或可扩展性问题，但是在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降的问题，享元模式正是为解决这一类问题而诞生的。

享元模式的定义与特点

享元（Flyweight）模式的定义：享元模式又称轻量级模式，是对象池（类似于线程池）的一种体现，运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。本质就是缓存共享对象，降低内存消耗

享元模式的主要优点是：
1.减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率；
2.减少内存之外的其他资源占用。

其主要缺点是：
1.为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
2.读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构

享元模式中存在以下两种状态：
1.内部状态，即不会随着环境的改变而改变的可共享部分；
2.外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要角色有如下。
抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（ConcreteFlyweight）角色：实现抽象享元角色中所规定的接口。
非享元（UnsharableFlyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（FlyweightFactory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象返回，并存入工厂。

享元模式的实现

/*
 * 抽象享元角色（Flyweight）: 票
*/
public interface ITicket {
    //展示方法
    void showInfo(String bunk);
}

//具体享元角色（Concrete Flyweight）:火车票
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;
    }
    //展示
    public void showInfo(String bunk) {
        this.price = new Random().nextInt(500);
        System.out.println(String.format("%s->%s：%s价格：%s 元", this.from, this.to, bunk, this.price));
    }
}

//享元工厂角色（Flyweight Factory）：负责创建和管理享元角色（火车票）
class TicketFactory {
    private static Map<String, ITicket> sTicketPool = new ConcurrentHashMap<String,ITicket>();//缓存池

    public static ITicket queryTicket(String from, String to) {
        String key = from + "->" + to;
        if (TicketFactory.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;
    }
}

//测试类：类中传递的参数就是非享元角色（Unsharable Flyweight)以参数的形式注入具体享元的相关方法中
public class Test {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.queryTicket("北京西", "长沙");
        ticket.showInfo("硬座");
        ticket = TicketFactory.queryTicket("北京西", "长沙");
        ticket.showInfo("软座");
        ticket = TicketFactory.queryTicket("北京西", "长沙");
        ticket.showInfo("硬卧");
    }
}

程序运行结果如下：

首次查询，创建对象: 郑州->杭州
郑州->杭州：硬座价格：230 元
首次查询，创建对象: 郑州西->杭州
郑州西->杭州：软座价格：291 元
首次查询，创建对象: 郑州->北京
郑州->北京：硬卧价格：148 元

享元模式的应用场景

当系统中多出需要同一组信息时，可以把这些信息封装到一个对象里，然后对该对象进行缓存，这样这个对象就可以提供给多处地方使用了，避免同一对象大量被创建，从而消耗大量内存空间。
享元模式其实就是工厂模式的一种改进，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法生成对象的，只不过享元模式中为工厂方法增加缓存这一功能。
主要总结以下场景：
1.常常应用于系统底层的开发，以便解决系统的性能问题。
2.系统有大量相似的对象，需要缓冲池的场景。

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

享元模式的定义为我们提出了两个要求：细粒度和共享对象。因为要求细粒度对象，所以不可避免的会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

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

比如，数据库连接池中的连接对象，保存在连接对象中的用户名、密码、url，在创建对象的时候就设置好了，这是固定不变的，不会随环境的改变而改变，这些就是内部状态。而每个连接都是要回收利用的，我们需要给他标记为可用状态，这些就是外部状态。

<<上一篇：外观（门面）模式
>>下一篇：组合模式