今天一起来看一个新的设计模式，那就是享元模式，关于此模式，常见的就是 “项目外包”、
以及 “五子棋” 这样两个例子，我们下面就选择使用 “项目外包” 这个例子引入去讲
一 故事引入
(一) 故事背景
程序员小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）所以请确认实例足够多的时候才值得去使用享元模式。