设计模式学习笔记之享元模式

我的个人博客：海加尔金鹰

什么是享元模式

享元模式的定义与意义

Use sharing to support large numbers of fine-grained objects efficiently.
使用共享对象可有效地支持大量的细粒度的对象。

在面向对象的过程当中，对象的创建是很常见的事情，当对象的的数量过多时，就会带来运行性能下降的问题（消耗了太多的内存）。
享元模式主要用来避免系统创建多个重复对象，达到减少内存消耗的目的。
享元对象能做到共享的关键是区分内部状态和外部状态，内部状态指的是对象创建不会在发生变化的属性，外部状态是指会发生改变的属性。
比较金典的例子说明：围棋游戏当中，存在大量的黑子和白子，每个黑子除了落点位置不同之外，其他的大小颜色都相同。通过享元模式只需要创建一个黑子对象。每次落子的时候获取到的黑子都是同一个对象，大大减少了对象的创建和销毁，提高了性能。

享元模式的结构与角色

享元模式四大角色：

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

享元模式结构实例图：

享元模式代码实现

享元模式两种分类：
单纯享元模式：不包含非享元角色的，所有的具体享元角色都是可以共享的。
复合享元模式：包含非享元角色，通过组合模式，为不同的单纯享元对象设置相同的外部状态。

单纯享元模式

第一步：创建享元角色类

public abstract class Flyweight {
    /**
     * location   表示位置属性，外部状态，会发生改变。
     */
    public abstract void setLocation(String location);
}
​

第二步：创建具体享元类，内部状态在创建对象时必须设置好。

public class ConcreteFlyweight extends Flyweight {
    //颜色   内部状态，创建后不会改变的属性
    private String color = null;

    //创建对象的时候必须设置好对象的内部状态，同时设置该构造器为protect  不允许在其他的地方创建该对象，只能通过享元工厂类创建。方便全局的管理。
    protected ConcreteFlyweight(String color){
        this.color=color;
    }

    @Override
    public void setLocation(String location) {
        // doSomething
        System.out.println("===color ：" +color+"===location ："+location);
    }
}
​

第三步：创建享元工厂类，通过单例模式保证每次获取到的工厂类都是同一个，不然无法实现全局共享。

public class FlyweightFactory {
    /**
     * 通过工厂模式控制享元对象的生成时，
     * 必须保证每次获取到的工厂是同一个工厂，
     * 所以采用单例模式来控制工厂模式的创建。
     */
    private static FlyweightFactory instance = new FlyweightFactory();

    private FlyweightFactory() {
    }

    public static FlyweightFactory getInstance() {
        return instance;
    }

    //享元池
    private Map<String, Flyweight> flyweightMap = new HashMap<>();
 	/**
     * 单纯享元对象获取
     * @param color
     * @return
     */
    public Flyweight getFlyweight(String color) {
		// 判断享元池是否包含这个享元对象
        if (flyweightMap.containsKey(color)) {
            return flyweightMap.get(color);
        } else {
       		//如果不包含就创建一个
            Flyweight flyweight = new ConcreteFlyweight(color);
            flyweightMap.put(color, flyweight);
            return flyweight;
        }
    }
    public void showNumber(){
        System.out.println("享元池里面现在有："+flyweightMap.size()+"个享元对象");
    }
}

​

第四步：创建测试类进行测试及结果

public class FlyweightTest {
    public static void main(String[] args) {
        FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();
        flyweightFactory.getFlyweight("黑色").setLocation("北京");
        flyweightFactory.getFlyweight("黑色").setLocation("南京");
        flyweightFactory.getFlyweight("黑色").setLocation("西京");
        flyweightFactory.getFlyweight("黑色").setLocation("东京");
        flyweightFactory.getFlyweight("白色").setLocation("北京");
        flyweightFactory.getFlyweight("白色").setLocation("上海");
        flyweightFactory.getFlyweight("红色").setLocation("广东");
        flyweightFactory.getFlyweight("红色").setLocation("北京");
        flyweightFactory.showNumber();
    }
}
​

===color ：黑色===location ：北京
===color ：黑色===location ：南京
===color ：黑色===location ：西京
===color ：黑色===location ：东京
===color ：白色===location ：北京
===color ：白色===location ：上海
===color ：红色===location ：广东
===color ：红色===location ：北京
享元池里面现在有：3个享元对象
​

可以看到只创建了三个对象。节省了对象的创建。

复合享元模式

在单纯享元模式的代码基础上，多了一个非享元角色，主要功能是为多个不同的享元对象设置统一的外部状态。
第一步：添加非享元角色

public class UnsharableFlyweight extends Flyweight {

    //用于保存单纯享元对象
    private Map<String,Flyweight> flys = new HashMap<>();

    /**
     * 增加一个新的单纯享元对象到集合中
     * @param key 
     * @param fly 单纯享元对象
     */
    public void add(String key , Flyweight fly){
        flys.put(key,fly);
    }

    /**
     * 为所有的单纯享元对象统一设置相同的外部状态
     * @param location
     */
    @Override
    public void setLocation(String location) {
        for (String s : flys.keySet()) {
            flys.get(s).setLocation(location);
        }
    }
}

​

第二步：在享元工厂类当中添加创建非享元对象的方法

   	/**
     * 复合享元工厂方法
     */
    public Flyweight getUnsharableFlyweight(List<String> colors){
        UnsharableFlyweight fly= new UnsharableFlyweight();
        for(String color: colors){
            fly.add(color,this.getFlyweight(color));
        }
        return fly;
    }
​

第三步：创建测试类进行测试及结果

public class FlyweightTest {
    public static void main(String[] args) {
        FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();
        List<String> colors = new ArrayList<>();
        colors.add("黑色");
        Flyweight flyweight1 = flyweightFactory.getUnsharableFlyweight(colors);
        Flyweight flyweight2 = flyweightFactory.getUnsharableFlyweight(colors);
        System.out.println("非享元角色是否可以共享对象：" + (flyweight1 == flyweight2));
        System.out.println("---------------------------------");
        String color = "白色";
        Flyweight fly1 = flyweightFactory.getFlyweight(color);
        Flyweight fly2 = flyweightFactory.getFlyweight(color);
        System.out.println("享元角色是否可以共享对象：" + (fly1 == fly2));
        flyweightFactory.showNumber();
    }
}
​

非享元角色是否可以共享对象：false
---------------------------------
享元角色是否可以共享对象：true
享元池里面现在有：2个享元对象
​

享元模式典型应用及总结

典型应用

可以参考 JAVA 里面的 String 类，Integer，Long 类等等。

享元模式优点

• 可以极大减少内存中对象的数量，节约系统资源，提高系统性能。
• 享元模式的内部状态不会改变，因此可以在不同的环境中被共享。

享元模式缺点

• 系统代码变得复杂多样，需要分离出内部状态和外部状态。

总结：个人感觉享元模式的使用频率应该会越来越少了，毕竟享元模式的主要目的是节约内存，提高性能。但是目前硬件条件的提升，渐渐弥补了内存不足的缺点。并且如果现在一个程序要占用非常高的内存的话，需要认真考量下这个程序到底设计的有没有问题。