java设计模式之享元模式

概述：

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

定义：

享元模式又叫作轻量级模式，是对象池的一种实现。类似线程池，线程池可以避免不停地创建和销毁多个对象，消耗性能。享元模式提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者都创建一个单独的对象，以此来降低内存的消耗，属于结构型设计模式

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

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

应用场景：

在生活中，享元模式非常常见，比如各中介机构的房源共享，再比如全国社保联网

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，降低大量内存空间的消耗

享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。主要应用场景如下

1. 常应用于系统底层的开发，以便解决系统的性能问题

2. 系统有大量相似对象，需要缓冲池的场景

UML类图：

 

1. 抽象享元角色（IFlyweight）：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现

2. 具体享元角色（ConcreteFlyweight）:实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不会出现一个操作改变内部状态，同时修改了外部状态

3. 享元工厂：负责管理享元对象池和创建享元模式

通用写法：

package com.design.pattern.flyweight;
​
import java.util.HashMap;
import java.util.Map;
​
public class Client {
    public static void main(String[] args) {
        FlyweightFactory flyweightFactory = new FlyweightFactory();
        IFlyweight flyweight1 = flyweightFactory.getFlyweight("aa");
        IFlyweight flyweight2 = flyweightFactory.getFlyweight("bb");
        flyweight1.operation("a");
        flyweight2.operation("b");
    }
    interface IFlyweight{
        void operation(String extrinsicState);
    }
    //具体享元角色
    static 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);
        }
    }
    //享元工厂
    static class FlyweightFactory{
        private static Map pool = new HashMap<>();
        //因为内部状态具备不变性，所以作为缓存的键
        public static IFlyweight getFlyweight(String intrinsicState){
            if (!pool.containsKey(intrinsicState)){
                IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
                pool.put(intrinsicState,flyweight);
            }
            return pool.get(intrinsicState);
        }
    }
}

示例：

举个例子，每年春节为了买到一张回家的火车票，大家都要大费周章。为了解决这一问题，12306网站提供了自动查票的功能。如果开启自动查票功能，则系统会将我们填写的信息缓存起来，然后定时查询余票信息。再买票的时候，我们肯定要查询一下有没有我们需要的车票，假设一张火车票包含出发站，目的站，价格，座位类别等信息。现在要求编写火车票查询模拟代码，可以通过出发站，目的站查到相关票的信息。

首先创建ITicket接口

package com.design.pattern.flyweight;
​
public interface ITicket {
    void showInfo(String bunk);
}

然后创建TrainTicket接口

package com.design.pattern.flyweight;
​
import java.util.Random;
​
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(500);
        System.out.println(String.format("%s->%s: %s 价格：%s 元",this.from,this.to,bunk,this.price));
    }
}

接着创建TicketFactory类

package com.design.pattern.flyweight;
​
public class TicketFactory {
    public static ITicket queryTicket(String from,String to){
        return new TrainTicket(from,to);
    }
}

最后编写客户端代码如下：

package com.design.pattern.flyweight;
​
public class TicketTest {
    public static void main(String[] args) {
        ITicket iTicket = TicketFactory.queryTicket("深圳北", "潮汕");
        iTicket.showInfo("硬座");
    }
}

由上面代码可以知道，当客户端进行查询时，系统通过TicketFactory直接创建一个火车票对象，但是这样做的话，当某个瞬间如果有大量用户查询同一张票的信息时，系统就会创建出大量该火车票对象，内存压力骤增。其实更好的做法应该是缓存该火车票对象，然后提供给其他查询请求复用，这样一个对象就足以支撑数以千计的查询请求，内存完全无压力，使用享元模式可以很好地解决这个问题。我们就像优化代码，只需在TicketFactory类中进行更改，增加缓存机制。

package com.design.pattern.flyweight;
​
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
​
public class TicketFactory {
//    public static ITicket queryTicket(String from,String to){
//        return new TrainTicket(from,to);
//    }
    private static Map sTicketPool = new ConcurrentHashMap<>();
    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);
        TrainTicket ticket = new TrainTicket(from, to);
        TicketFactory.sTicketPool.put(key,ticket);
        return ticket;
    }
}

运行结果如下图所示

首次查询，创建对象：深圳北->潮汕
深圳北->潮汕: 硬座 价格：111 元
首次查询，创建对象：北京西->长沙
北京西->长沙: 软座 价格：146 元
​
Process finished with exit code 0

可以看到，除了第一次查询创建对象，后续查询相同车次票的信息都使用缓存对象，不需要创建新对象。

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

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

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

比如，连接池中的连接对象，保存在连接对象中的用户名，密码，连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

优点：

1. 减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率

2. 减少内存之外的其他资源占用

缺点：

1. 关注内外部状态，关注线程安全问题

2. 使系统，程序的逻辑复杂性