十三、享元模式

一、什么是享元模式

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

享元（Flyweight）模式包含以下主要角色。

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

二、享元模式的实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。
比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

享元模式的本质是缓存共享对象，降低内存消耗。

抽象享元

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/6 0006 11:39
 * @description 抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
 */
public interface Flyweight {
    void operation(UnsharableFlyweight unsharableFlyweight);
}

非享元


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/6 0006 11:41
 * @description 非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
 */
public class UnsharableFlyweight {

    private int times = 1;

    public int getTimes() {
        return times;
    }

    public void setTimes(int times) {
        this.times = times;
    }

    @Override
    public String toString() {
        return "UnsharableFlyweight{" +
                "times=" + times +
                '}';
    }
}

具体享元


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/6 0006 11:42
 * @description 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
 */
public class ConcreteFlyweight implements Flyweight {
    private String key ;

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

    @Override
    public void operation(UnsharableFlyweight unsharableFlyweight) {
        System.out.println("进入享元..........................key:"+key);
        System.out.println("享元"+key+"第"+unsharableFlyweight.getTimes()+"次被执行");
        unsharableFlyweight.setTimes(unsharableFlyweight.getTimes()+1);
    }
}

享元工厂


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/6 0006 11:43
 * @description 元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在
 *              符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。
 */
public class FlyweightFactory  {
    private Map<String, Flyweight> flyweightMap = new HashMap<>();

    public Flyweight getFlyweight(String key){
        Flyweight flyweight = flyweightMap.get(key);
        if (flyweight!=null){
            System.out.println("具体享元"+key+"已经存在，被成功获取！");
        }else{
            flyweight=new ConcreteFlyweight(key);
            flyweightMap.put(key, flyweight);
            System.out.println("具体享元"+key+"不存在，已成功创建享元"+key+"！");
        }
        return flyweight;
    }
}

测试类


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/6 0006 11:38
 * @description 享元模式
 *
 * 在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。
 * 享元模式的定义与特点：
 * 享元（Flyweight）模式的定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。
 *
 * 享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
 *
 * 其主要缺点是：为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
 * 读取享元模式的外部状态会使得运行时间稍微变长。
 * 享元模式的结构与实现：
 * 享元模式中存在以下两种状态：内部状态，即不会随着环境的改变而改变的可共享部分；
 * 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。下面来分析其基本结构和实现方法。
 * 模式的结构：
 * 享元模式的主要角色有如下。抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
 * 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
 * 非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
 * 享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。
 * 享元模式的应用场景：
 * 享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
 * 大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
 * 由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。
 *
 */
public class Main {
    /**
     * 享元模式测试
     */
    @Test
    public void flyweightTest(){
        FlyweightFactory flyweightFactory = new FlyweightFactory();
        Flyweight fly1_1 = flyweightFactory.getFlyweight("fly1");
        Flyweight fly1_2 = flyweightFactory.getFlyweight("fly1");
        Flyweight fly1_3 = flyweightFactory.getFlyweight("fly1");
        UnsharableFlyweight fly1_unSharable = new UnsharableFlyweight();
        Flyweight fly2_1 = flyweightFactory.getFlyweight("fly2");
        Flyweight fly2_2 = flyweightFactory.getFlyweight("fly2");
        UnsharableFlyweight fly2_unSharable = new UnsharableFlyweight();
        fly1_1.operation(fly1_unSharable);
        fly1_2.operation(fly1_unSharable);
        fly1_3.operation(fly1_unSharable);
        fly2_1.operation(fly2_unSharable);
        fly2_2.operation(fly2_unSharable);
    }
}

运行结果：

具体享元fly1不存在，已成功创建享元fly1！
具体享元fly1已经存在，被成功获取！
具体享元fly1已经存在，被成功获取！
具体享元fly2不存在，已成功创建享元fly2！
具体享元fly2已经存在，被成功获取！
进入享元..........................key:fly1
享元fly1第1次被执行
进入享元..........................key:fly1
享元fly1第2次被执行
进入享元..........................key:fly1
享元fly1第3次被执行
进入享元..........................key:fly2
享元fly2第1次被执行
进入享元..........................key:fly2
享元fly2第2次被执行