明天一起来看一个新的设计模式，那就是享元模式，对于此模式，常见的就是“我的项目外包”、
以及“五子棋”这样两个例子，咱们上面就抉择应用“我的项目外包”这个例子引入去讲

一 故事引入

(一) 故事背景

程序员小 B，帮忙客户 A 做了一个展现一些产品内容的网站，通过 A 的 举荐，客户 B、客户 C 也想要做这样一个网站，然而就是模式有一些变动

• 有的客户心愿是新闻公布模式的
• 有的客户心愿是博客模式的
• 有的客户心愿是公众号模式的等等

而且他们都心愿可能升高一些费用，然而每一个空间部署着一个网站，所以租借空间的费用是固定的，同时程序员小 B 并不想从本人的劳动报酬中缩减费用

(二) 思考解决方案

(1) 最简略的传统计划

先说最简略能想到的计划，间接把网站代码复制几份，而后每一个都租借一个空间，而后对代码进行定制批改。注：这里还没思考优化或者省钱

咱们用一个 WebSite 类来模仿一个网站的模板，所有类型能够通过对 name 赋值而后调用 use 办法进行批改

public class WebSite {
    private String name = "";

    public WebSite(String name) {this.name = name;}

    public void use(){System.out.println("以后网站分类:" + name);
    }
}

如果依照方才的思路，是这样操作的

public class Test {public static void main(String[] args) {WebSite webSite1 = new WebSite("博客");
        webSite1.use();

        WebSite webSite2 = new WebSite("博客");
        webSite2.use();

        WebSite webSite3 = new WebSite("博客");
        webSite3.use();

        WebSite webSite4 = new WebSite("新闻公布");
        webSite4.use();

        WebSite webSite5 = new WebSite("公众号");
        webSite5.use();

        WebSite webSite6 = new WebSite("公众号");
        webSite6.use();}
}

运行后果：

以后网站分类: 博客
以后网站分类: 博客
以后网站分类: 博客
以后网站分类: 新闻公布
以后网站分类: 公众号
以后网站分类: 公众号

(2) 存在的问题及改良思路

• ① 假如虚拟空间在同一台服务器上，做上述内容，须要实例化 6 个 WebSite，而其本质又没有很大的差异，所以对于服务器的资源节约很大
• ② 网站构造类似度很高，根本全是反复的代码

对于这种重复性很高的内容，首先咱们要做到将其形象进去，反复创立实例在设计模式中必定是不太理智的，咱们想要做到多个客户，共享同一个实例。这样不论是代码还是服务器资源利用，都会改善很多

一个不算特地失当的例子：例如外卖平台中的一个一个商家店铺，是不是能够了解为平台中的一个小店铺，小网站，其中通过例如店铺 ID 等内容来辨别不同店铺，然而其每一家店铺整体的模板和样子是差不多的。

咱们上面要做的就是，将大量类似内容形象成一个网站模板类，而后把一些特定的内容，通过参数移到实例的里面，调用的时候再指定，这样能够大幅度缩小单个实例的数目。

(3) 享元模式初步改良

创立一个形象的 WebSite 类

public abstract class WebSite {public abstract void use();
}

接下来是具体实现，创立其子类，和后面一样，所有类型能够通过对 type 赋值而后调用 use 办法进行批改

public class ConcreteWebSite extends WebSite {

    // 网站公布模式
    private String type = "";

    public ConcreteWebSite(String type) {this.type = type;}

    @Override
    public void use() {System.out.println("以后网站分类:" + type);
    }
}

创立一个工厂类，用于创立，返回一个指定的网站实例

这一个类，首先用一个 HashMap 模仿一种连接池的概念，因为咱们既然想要达到不反复创立实例的成果，就须要通过一些逻辑判断，判断 Map 中是否存在这个实例，如果有就间接返回，如果没有就创立一个新的，同样类型 type 是在调用时，显式的指定的。

前面补充了一个获取网站分类总数的办法，用来测试的时候，看一下是不是没有反复创立实例

import java.util.HashMap;

/**
 * 网站工厂类，依据须要返回
 */
public class WebSiteFactory {
    // 模仿一个连接池
    private HashMap<String, ConcreteWebSite> pool = new HashMap<>();

    /**
     * 获取网站：依据传入的类型，返回网站，无则创立，有则间接返回
     *
     * @param type
     * @return
     */
    public WebSite getWebSiteCategory(String type) {if (!pool.containsKey(type)) {
            // 创立一个网站，放到池种
            pool.put(type, new ConcreteWebSite(type));
        }
        return (WebSite) pool.get(type);
    }

    /**
     * 获取网站分类总数
     */
    public int getWebSiteCount() {return pool.size();
    }

}

测试一下

public class Test {public static void main(String[] args) {
        // 创立一个工厂
        WebSiteFactory factory = new WebSiteFactory();

        // 给客户创立一个博客类型的网站
        WebSite webSite1  = factory.getWebSiteCategory("博客");
        webSite1.use();

        // 给客户创立一个博客类型的网站
        WebSite webSite2  = factory.getWebSiteCategory("博客");
        webSite2.use();

        // 给客户创立一个博客类型的网站
        WebSite webSite3  = factory.getWebSiteCategory("博客");
        webSite3.use();

        // 给客户创立一个新闻公布类型的网站
        WebSite webSite4  = factory.getWebSiteCategory("新闻公布");
        webSite4.use();

        // 给客户创立一个公众号类型的网站
        WebSite webSite5  = factory.getWebSiteCategory("公众号");
        webSite5.use();

        // 给客户创立一个公众号类型的网站
        WebSite webSite6  = factory.getWebSiteCategory("公众号");
        webSite6.use();

        // 查看一下连接池中的实例数
        System.out.println("实例数：" + factory.getWebSiteCount());
    }
}

运行后果：

以后网站分类: 博客
以后网站分类: 博客
以后网站分类: 博客
以后网站分类: 新闻公布
以后网站分类: 公众号
以后网站分类: 公众号
实例数：3

(4) 享元模式再改良 - 辨别内外部状态

下面的代码，应用工厂代替了间接实例化的形式，工厂中，次要通过一个池的概念，实现了共享对象的目标，然而其实咱们会发现，例如创立三个博客类型的网站，然而如同这三个网站就是截然不同的，然而不同的客户，其中博客网站中的数据必定是不同的，这就是咱们还没有辨别外部内部的状态

外部状态：对象共享进去的信息，存储在享元对象外部并且不会随环境扭转的共享局部

内部状态：对象用来标记的一个内容，随环境会扭转，不可共享

打个比方，五子棋只有黑白两色，总不能下多少子，就创立多少个实例吧，所以咱们把色彩看做外部状态，有黑白两种色彩。而各个棋子的地位并不相同，当咱们落子后这个地位信息才会被传入，所以地位信息就是内部状态

那么对于“外包网站”的例子中，很显然，不同的客户网站数据就是一个内部状态，上面来批改一下

首先新增一个 User 类，前面会将其引入作为内部状态

public class User {
    private String name;

    public User(String name) {this.name = name;}

    public String getName() {return name;}
}

批改抽象类和子类，通过参数的形式引入 User 这个内部状态

抽象类

public abstract class WebSite {public abstract void use(User user);
}

子类

public class ConcreteWebSite extends WebSite {

    // 网站公布模式
    private String type = "";

    public ConcreteWebSite(String type) {this.type = type;}

    @Override
    public void use(User user) {System.out.println("【网站分类】:" + type + "【客户】:" + user.getName());
    }
}

工厂类不变，最初批改测试类

public class Test {public static void main(String[] args) {
        // 创立一个工厂
        WebSiteFactory factory = new WebSiteFactory();

        // 给客户创立一个博客类型的网站
        WebSite webSite1  = factory.getWebSiteCategory("博客");
        webSite1.use(new User("客户 A"));

        // 给客户创立一个博客类型的网站
        WebSite webSite2  = factory.getWebSiteCategory("博客");
        webSite2.use(new User("客户 B"));

        // 给客户创立一个博客类型的网站
        WebSite webSite3  = factory.getWebSiteCategory("博客");
        webSite3.use(new User("客户 C"));

        // 给客户创立一个新闻公布类型的网站
        WebSite webSite4  = factory.getWebSiteCategory("新闻公布");
        webSite4.use(new User("客户 A"));

        // 给客户创立一个公众号类型的网站
        WebSite webSite5  = factory.getWebSiteCategory("公众号");
        webSite5.use(new User("客户 A"));

        // 给客户创立一个公众号类型的网站
        WebSite webSite6  = factory.getWebSiteCategory("公众号");
        webSite6.use(new User("客户 B"));

        // 查看一下连接池中的实例数
        System.out.println("实例数：" + factory.getWebSiteCount());
        
    }
}

运行后果：

【网站分类】: 博客【客户】: 客户 A
【网站分类】: 博客【客户】: 客户 B
【网站分类】: 博客【客户】: 客户 C
【网站分类】: 新闻公布【客户】: 客户 A
【网站分类】: 公众号【客户】: 客户 A
【网站分类】: 公众号【客户】: 客户 B
实例数：3

能够看进去，尽管有 6 个客户，然而实际上只有三个实例，同样再减少几十个，也最多只会有三个实例

二 享元模式概念

(一) 概念

定义：享元（Flyweight）模式使用共享技术来无效地反对大量细粒度对象的复用。

它通过共享曾经存在的对象来大幅度缩小须要创立的对象数量、防止大量类似类的开销，从而进步系统资源的利用率。

享元模式又叫做蝇量模式，所以英文为 Flyweight

(二) 结构图

注：办法参数和返回值没细细弄，次要为了阐明构造

• 形象享元角色（Flyweight）：是所有的具体享元类的超类或接口，非享元的内部状态以参数的模式通过办法传入。
• 具体享元（Concrete Flyweight）角色：实现形象享元角色中所规定的接口。
• 非享元（Unsharable Flyweight) 角色：是不共享的内部状态，它以参数的模式注入具体享元的相干办法中，这也意味着，享元模式并不强制共享

• 享元工厂（Flyweight Factory）角色：负责创立和治理享元角色。

  • 当客户对象申请一个享元对象时，享元工厂检査零碎中是否存在符合要求的享元对象

    • 如果存在则提供给客户
    • 如果不存在的话，则创立一个新的享元对象

(二) 简述优缺点

长处：雷同对象只须要保留一份，升高了零碎中内存的数量，缩小了零碎内存的压力

毛病：程序复杂性增大，同时读取享元模式的内部状态会使得运行工夫略微变长

(三) 利用场景

享元模式其中也须要一个工厂进行管制，所以就如同是在工厂办法模式的根底上，减少了一个缓存机制，也就是通过一个“池”的概念，防止了大量雷同的对象创立，大大降低了内存空间的耗费。

那么利用场景如下：

• 一个程序应用了大量类似或者雷同的对象，且造成了很大的开销的时候

• 大部分对象，能够依据外部状态分组，且可将不同局部内部化，这样每一个组只需保留一个外部状态。

  • 例如下面的博客，新闻，公众号站模式就是三种组，每个组只须要传入用户数据这个内部状态即可
• 因为应用享元模式，须要一个保留享元的数据结构（例如下面的 Hashmap）所以请确认实例足够多的时候才值得去应用享元模式。