一、介绍

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

二、内部状态和外部状态

比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一点，所以棋子颜色就是棋子的内部状态，而各个棋子之间的差别就是位置的不同，当我们落子后，落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态
1）享元模式提出了两个要求:细粒度和共享对象。这里就涉及到内部状态和外部状态了，即将对象的信息分为两个部分:内部状态和外部状态
2）内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
3）外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
4）举个例子：围棋理论上有361个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题

三、棋子项目

享元类

package com.swust.java.结构型模式.享元模式;

/**
 * 享元类
 */
public interface Chess {
    void setColor(String c);
    String getColor();
    void display(Coordinate c);
}

/**
 * 具体享元类
 */
class ConcreteChess implements Chess{

    private String color; // 内部状态

    public ConcreteChess(String color) {
        this.color = color;
    }

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

    @Override
    public String getColor() {
        return color;
    }

    @Override
    public void display(Coordinate c) { // 传入外部状态
        System.out.println("棋子颜色:"+color+" 棋子位置: "+c.getX()+"--"+c.getY());
    }
}

享元工厂

package com.swust.java.结构型模式.享元模式;

import java.util.HashMap;
import java.util.Map;

/**
 * 享元工厂
 */
public class ChessFactory {

    // 享元池
    private static Map<String,Chess> map = new HashMap<>();

    public static Chess getChess(String color){
        if(!map.containsKey(color)){
            map.put(color,new ConcreteChess(color));
        }
        return map.get(color);
    }

}

外部状态

package com.swust.java.结构型模式.享元模式;

/**
 * 非共享享元类
 * 棋子坐标类   外部状态
 */
public class Coordinate {
    private int x,y;

    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

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

    public int getY() {
        return y;
    }

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

测试类

package com.swust.java.结构型模式.享元模式;

public class Client {
    public static void main(String[] args) {
        Chess chess1 = ChessFactory.getChess("黑");
        Chess chess2 = ChessFactory.getChess("白");
        System.out.println("棋子内部状态");
        System.out.println(chess1.getColor());
        System.out.println(chess2.getColor());

        System.out.println("增加外部状态");
        chess1.display(new Coordinate(10,10));
        chess2.display(new Coordinate(20,20));
        chess1.display(new Coordinate(10,20));
    }
}

执行结果

棋子内部状态
黑
白
增加外部状态
棋子颜色:黑 棋子位置: 10--10
棋子颜色:白 棋子位置: 20--20
棋子颜色:黑 棋子位置: 10--20

四、Integer源码

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

Integer.valueOf(x);

如果x在-127 - 128 之间就用享元模式返回

五、注意事项

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