结构型模式（六）：享元模式

1、模式的定义与特点

享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

优点：
相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点：
1、为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
2、读取享元模式的外部状态会使得运行时间稍微变长。

2、模式的结构

享元模式中存在以下两种状态：
1、内部状态，即不会随着环境的改变而改变的可共享部分；
2、外部状态，指随环境改变而改变的不可以共享的部分。
享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

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

图1是享元模式的结构图。
（1）图中的UnsharedConcreteFlyweight是非享元角色，里面包含了非共享的外部状态信息 info；
（2）而Flyweight是抽象享元角色，里面包含了享元方法operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
（3）ConcreteFlyweight是具体享元角色，包含了关键字key，它实现了抽象享元接口；
（4）FlyweightFactory是享元工厂角色，它视关键字key来管理具体享元；
（5）客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

图1 享元模式的结构图

3、模式的应用场景

享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式：
1、系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
2、大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
3、由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

4、模式的扩展

享元模式通常包含可以共享的部分和不可以共享的部分。
在实际使用过程中，存在两种特殊的享元模式：单纯享元模式和复合享元模式。
1、单纯享元模式，所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构如图2所示。

图2 单纯享元模式的结构图

2、复合享元模式，有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享，其结构图如图3所示。

图3 复合享元模式的结构图

5、模式的实现

图4 示例代码结构图

抽象享元角色:

package com.example.designpattern.flyweight;

/**
 * @author Administrator
 * @date 2020/8/3
 * 抽象享元角色
 */
interface IFlyweight {
    /**
     * @param outState 外蕴状态，在客户端使用时传入的，可以变化的状态
     */
    public void operate(String outState);
}

具体享元角色:

package com.example.designpattern.flyweight;

/**
 * @author Administrator
 * @date 2020/8/3
 * 具体享元角色
 * 实现抽象享元角色并提供存储内蕴状态
 */
class ConcreteFlyweight implements IFlyweight {
    /**
     * 内蕴状态
     */
    private String innerState;

    public ConcreteFlyweight(String innerState) {
        this.innerState = innerState;
    }

    @Override
    public void operate(String outState) {
        System.out.println("内蕴状态-" + innerState);
        System.out.println("外蕴状态：" + outState);
    }
}

享元工厂角色:

package com.example.designpattern.flyweight;

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

/**
 * @author Administrator
 * @date 2020/8/3
 * 享元工厂角色
 * 负责创建和管理享元对象
 */
class FlyweightFactory {
    /**
     * 使用Map来存储享元对象
     * key: String类型，表示享元对象的内蕴状态
     * value: IFlyweight，表示享元对象
     */
    private Map<String, IFlyweight> map = new HashMap<>();

    /**
     * 负责创建享元对象
     *
     * @param innerState 享元对象的内蕴在Map中作为key存在时，就返回已有的享元对象。
     *                   若不存在，就创建一个新的合适的享元对象，并存储在Map中。
     * @return 返回享元对象
     */
    public IFlyweight factory(String innerState) {
        IFlyweight iFlyweight = map.get(innerState);

        if (iFlyweight == null) {
            //创建一个享元对象并保存
            iFlyweight = new ConcreteFlyweight(innerState);
            map.put(innerState, iFlyweight);
        }

        return iFlyweight;
    }
}

调用:

package com.example.designpattern.flyweight;

/**
 * @author Administrator
 * @date 2020/8/3
 */
class Client {
    public static void main(String[] args) {
        //必须通过享元工厂来创建享元对象
        FlyweightFactory mFactory = new FlyweightFactory();

        IFlyweight f1 = mFactory.factory("a");
        f1.operate("第一次调用享元工厂，获取享元对象");

        IFlyweight f2 = mFactory.factory("b");
        f2.operate("第二次调用享元工厂，获取享元对象");

        IFlyweight f3 = mFactory.factory("a");
        f3.operate("第三次调用享元工厂，获取享元对象");


        System.out.println();


        //判断享元对象是否相等
        System.out.println("享元对象f1=f2：" + (f1 == f2));
        System.out.println("享元对象f1=f3：" + (f1 == f3));
    }
}

测试结果:

图5 测试结果

6、PPT素材

微信公众号: TechU