共计 5454 个字符，预计需要花费 14 分钟才能阅读完成。
明天一起来看一个新的设计模式，那就是享元模式，对于此模式，常见的就是“我的项目外包”、
以及“五子棋”这样两个例子，咱们上面就抉择应用“我的项目外包”这个例子引入去讲
一 故事引入
(一) 故事背景
程序员小 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）所以请确认实例足够多的时候才值得去应用享元模式。
