享元模式

一、享元模式基本介绍：

• ①：运用共享技术有效地支持大量细粒度的对象
• ②：常用于系统底层开发，解决系统的性能问题，像数据库连接池，里面都是创建好的连接对象。在这些连接对象中有我们需要的则直接拿来用，避免重新创建；如果没有我们需要的，则创建一个。
• ③：享元模式能够解决重复对象的内存浪费的问题。当系统中有大量相似对象，需要缓冲池时。不需总是创建新对象，可以从缓冲池里那。这样可以降低系统内存，同时提高效率。
• ④：享元模式的经典应用场景就是池技术。例如：String常量池、数据库连接池、缓冲池等等，都是享元模式的应用。享元模式是池技术的重要实现方式。

二、享元模式的内部状态、外部状态基本介绍：

比如围棋、五子棋、跳棋，它们都有大量的棋子对象。围棋和五子棋只有黑白两种，跳棋颜色多一点，所以棋子的颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同。当我们落子后，落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态。

• ①：享元模式提出了两个要求：细粒度 和 共享对象，这里就涉及到内部状态、外部状态了。及将对象信息分为两个部分：内部状态 和 外部状态。
• ②：内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变。
• ③：外部状态值对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。

三、使用案例

案例一：

围棋理论上有361个空位置可以放置棋子，每个棋盘都有可能有两三百个棋子对象产生。因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏。如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题。

案例二：

小型的外包项目，给客户A做一个产品展示网站。客户就A的朋友感觉效果不错，也希望做这样的产品展示网站，但是要求有些不同：

• ①：有的客户要求以新闻的形式发布
• ②：有的客户要求以博客的形式发布
• ③：有的客户要求以产品的形式发布

四、案例代码

创建抽象棋子一AbstractChessman

public abstract class AbstractChessman {
    // 棋子坐标
    protected int x;
    protected int y;
    // 棋子类别（黑|白）
    protected String chess;
    public AbstractChessman(String chess) {
        this.chess = chess;
    }
    // 点坐标设置
    public abstract void point(int x, int y);
    // 显示棋子信息
    public void show() {
        System.out.println(this.chess + "(" + this.x + "," + this.y + ")");
    }
}

创建黑子一BlackChessman

public class BlackChessman extends AbstractChessman {
    /**
     * 构造方法 初始化黑棋子
     */
    public BlackChessman() {
        super("●");
        System.out.println("--BlackChessman Construction Exec!!!");
    }
    // 点坐标设置
    @Override
    public void point(int x, int y) {
        this.x = x;
        this.y = y;
        // 显示棋子内容
        show();
    }
}

创建白子一WhiteChessman

public class WhiteChessman extends AbstractChessman {
    /**
     * 构造方法 初始化白棋子
     */
    public WhiteChessman() {
        super("○");
        System.out.println("--WhiteChessman Construction Exec!!!");
    }
    // 点坐标设置
    @Override
    public void point(int x, int y) {
        this.x = x;
        this.y = y;
        // 显示棋子内容
        show();
    }
}

创建棋子工厂一FiveChessmanFactory

public class FiveChessmanFactory {
    // 单例模式工厂
    private static final FiveChessmanFactory FIVE_CHESSMAN_FACTORY_INSTANCE = new FiveChessmanFactory();
    // 缓存存放共享对象
    private final Hashtable<Character, AbstractChessman> cache = new Hashtable<>();
    // 私有化构造方法
    private FiveChessmanFactory() {
    }
    // 获得单例工厂
    public static FiveChessmanFactory getInstance() {
        return FIVE_CHESSMAN_FACTORY_INSTANCE;
    }
    /**
     * 根据字符获得棋子
     *
     * @param color （B：黑棋 W：白棋）
     * @return
     */
    public AbstractChessman getChessmanObject(char color) {
        // 从缓存中获得棋子对象实例
        AbstractChessman abstractChessman = this.cache.get(color);
        // 缓存中没有棋子对象实例信息 则创建棋子对象实例 并放入缓存
        if (abstractChessman == null) {
            switch (color) {
                case 'B':
                    abstractChessman = new BlackChessman();
                    this.cache.put(color, abstractChessman);
                    break;
                case 'W':
                    abstractChessman = new WhiteChessman();
                    this.cache.put(color, abstractChessman);
                    break;
                default:
                    return null;
            }
        }
        // 如果缓存中存在 棋子对象则直接返回
        return abstractChessman;
    }
}

客户端实现一Client

/**
 * 主应用程序
 */
public class Client {
    public static void main(String[] args) {
        // 创建五子棋工厂
        FiveChessmanFactory fiveChessmanFactory = FiveChessmanFactory.getInstance();
        // 随机获得棋子
        for (int i = 0; i < 10; i++) {
            AbstractChessman abstractChessman = null;
            switch (RandomUtil.randomInt(0, 2)) {
                // 获得黑棋
                case 0:
                    abstractChessman = fiveChessmanFactory.getChessmanObject('B');
                    break;
                // 获得白棋
                case 1:
                    abstractChessman = fiveChessmanFactory.getChessmanObject('W');
                    break;
            }
            if (abstractChessman != null) {
                abstractChessman.point(RandomUtil.randomInt(1, 16), RandomUtil.randomInt(1, 16));
            }
        }
    }
}

输出内容：

--WhiteChessman Construction Exec!!!
○(3,15)
○(4,11)
--BlackChessman Construction Exec!!!
●(6,12)
○(9,4)
●(9,4)
●(14,15)
○(15,2)
●(8,11)
○(11,13)
○(11,3)

五、存在的问题

举一个简单例子：

一个游戏中有不同的英雄角色，同一类型的角色也有不同属性的英雄。如刺客类型的英雄有很多个，按此种模式设计，利用英雄所属类型去引用原有同一类型的英雄实例，然后对其相应属性进行修改，便可得到最终想得到的最新英雄。

比如说你创建了第一个刺客型英雄，然后需要设计第二个刺客型英雄，你利用第一个英雄改变属性得到第二个刺客英雄，最新的刺客英雄是诞生了，但第一个刺客英雄的属性也随之变得与第二个相同，这种情况显然是不可以的。

六、享元模式的注意事项和细节：

• ①：享元模式这样理解：“享”表示“共享”、“元”表示“对象”。
• ②：系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元模式。
• ③：用唯一标识码判断，如果内存中有，则返回这个唯一标识码所标识的对象。用HashMap/HashTable存储。
• ④：享元毛大大减少了对象的创建，降低了程序内存的占用，提供效率。
• ⑤：享元模式提供了系统的复杂度，需要分离出内部状态、外部状态。而内部状态具有固定性，不应该随着环境的改变而改变。这是我们使用享元毛hi需要注意的地方。
• ⑥：使用享元模式时，注意划分内部状态、外部状态，并且需要有一个工厂类加以控制。
• ⑦；享元模式经典的应用场景是使用缓冲池场景，比如String常量池、数据库连接池。