设计模式之享元模式

---

1.定义

享元模式属于结构型模式中的一种，其目的是为了减少大量相似对象的创建，降低资源消耗，提高系统的性能。从本质上看，享元模式是利用共享的方式使得大量的细粒度对象能够被复用，大幅减少需要创建的对象数量，以达到高效利用资源。

最熟悉的实现实例就是数据库连接池、线程池、Integer缓存，提到这几个，就能对享元有一个大概的认识方向，具体做法就是提前创建他们， 并缓存到指定的容器，当需要对象时，从该容器获取，使用结束后，将对象返还给容器，而容器也可以根据实际的情况，添加/删除对象，或者进行扩缩容。

关键点：
在这样的对象共享机制下，根据对象的状态分为两部分：

• 内部状态：所有对象抽象层面共享的部分，这部分在所有对象内部都是常量，不会随着外部环境改变而改变
• 外部状态：外部状态会因为外部环境的改变而发生改变

怎么理解？其实就是将对象可变部分和不可变的部分分离，不可变的部分维护在对象内部，可变部分通过参数的方式对外提供出去，获取对象的时候，由外部来设定该参数，从而获取到真正需要的对象
比如以围棋为例，棋盘上那么多棋子，如果每个棋子都用一个单独的对象表示，会产生大量的对象，而且它们都是相似的，实际上对象只有白棋和黑棋两种，他们都是棋子，形状相同，质量相同（内部状态）…，不同的是颜色，和落棋位置（外部状态）

总结：享元类包含原始对象中部分能在多个对象中共享的状态，同一享元对象可在许多不同场景中使用，享元中存储的状态被称之为内部状态，传递给享元方法的状态被称作外部状态

通过分离两种状态，对内在状态重用，使得所需的对象数量大大减少，毕竟与外在状态相比，内在状态的变体要少很多

至此，可以看出享元模式最重要的其实就是不变部分和可变部分的分离。

---

角色介绍：

• 抽象享元角色（FlyWeight）：是所有具体享元类的抽象类，提供所有具体享元类需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入
• 具体享元角色（Concrete Flyweight）：实现抽象享元角色中规定的接口
• 非享元角色（Unsharable Flyweight）：是不可以共享的外部状态，它以参数的形式注入具体的享元的方法中
• 享元工厂角色（Flyweight Factory）：负责创建和管理享元角色，当客户端请求一个享元对象时，享元工厂负责检查是否存在符合要求的享元对象，如果存在，则返回，如果不存在，创建并返回，这是一个解耦的过程。

图片来源：知乎

2.示例

以棋子为例，对享元模式进行一个简单的实现，具体做法

1. 通过对享元对象分析，将享元对象拆分出两个部分，内在部分和外在部分，这也是享元设计模式中最关键的一步
2. 内在部分的成员属于所有享元对象共有属性，一般是只读状态，外在部分成员通过方法参数的形式暴露出去，允许外部修改
3. 最后就是定义一个工厂类，来负责管理和创建享元对象，具体实现方式根据实际情况灵活设计

首先先创建享元的抽象角色，也就是棋子的抽象层

/**
 * @description: 抽象享元角色
 * @version: 1.0
 */
public interface ChessPieces {

    void downPieces();
}

对棋子进行实现，具体实现可以根据实际的情况有多个，这里只使用一个说明原理

如果将所有对象的共享状态简化成一个享元对象，有点类似单例，不同的是单例只有一个实体，而享元可以有多个，每个实体的内在状态也可以不同

/**
 * @description: 具体享元角色
 * @version: 1.0
 */
public class ConcretePieces implements ChessPieces{
	
	//外部状态
    private int x;
    private int y;
    private String color;
    
    //内部状态
    private String shape;
    
    //其他内部状态
    //.....

    public ConcretePieces(){
        this("circle");
    }
    public ConcretePieces(String shape){
        this.shape = shape;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public void downPieces() {
        System.out.println(shape + ":" +color + "=>(" + x + "," + y + ")" );
    }

}

定义一个工厂类，用于管理所有的享元对象

/**
 * @description: 管理工厂
 * @version: 1.0
 */
public class PiecesFactory {

    private static final Map<String,ChessPieces> cache  = new HashMap<>();

    public static ChessPieces getPieces(String color,int x,int y){
        ConcretePieces chessPieces = (ConcretePieces) cache.get(color + y + y);

		//如果不存在，则创建 并缓存
        if (chessPieces == null){
            chessPieces = new ConcretePieces();
            chessPieces.setColor(color);
            chessPieces.setX(x);
            chessPieces.setY(y);
            cache.put(color+x+y,chessPieces);
        }
        return chessPieces;
    }
}

测试：

/**
 * @description: test
 * @version: 1.0
 */
public class Test {

    private static final String PIECES_COLOR[] = {"white","black"};

    public static void main(String[] args) {

        for (int i = 0 ; i < 10; i++){
            String color = PIECES_COLOR[i % 2];
            int x = (int)(Math.random()*100);
            int y = (int)(Math.random()*100);
            ChessPieces pieces = PiecesFactory.getPieces(color, x, y);
            pieces.downPieces();
        }
    }
}

input:

circle:white=>(51,25)
circle:black=>(52,1)
circle:white=>(52,6)
circle:black=>(65,40)
circle:white=>(87,9)
circle:black=>(64,0)
circle:white=>(5,24)
circle:black=>(34,30)
circle:white=>(60,72)
circle:black=>(41,31)

以上是对享元模式的一个简单实现，当然，实际应用中远远复杂许多，设计模式只是提供了一个思想的基础框架，具体实现还需要根据实际的情况来衡量。

如果系统中需要经常创建许多相似的对象，并且内存很珍贵，在没有其他更好的解决方案情况下，使用享元模式是其中一个可以考虑的方向。

3.总结

享元模式的优点在于它可以极大的减少内存中对象的数量，使得相同或相似的对象在内存中的数量是相对固定的，并且由于其划分内外状态的思想，享元模式有很好的独立性，外部状态的改变不会影响到内部状态，可以使享元对象在不同环境中被共享使用。
享元模式的缺点也是显而易见的，其一是将对象状态分离增加了一定的复杂性，其二是将部分成员外部化，读取外部状态使得运行时间增加。