I walk very slowly, but I never walk backwards 设计模式 - 享元模式
寂然
大家好，我是寂然，本节课，我们来聊设计模式中的享元模式，老规矩，首先我们先通过一个案例需求来引入
案例演示 - 网站项目
首先我们来看这样一个需求：
我们接了一个小型的外包项目，给客户老王做一个产品展示网站，老王的朋友们感觉效果不错，也希望做这样的产品展示网站，但是他们要求都有些不同
1）有客户要求以新闻的形式发布
2）有客户人要求以博客的形式发布
3）有客户希望以微信公众号的形式发布
解决方案一：一般实现
OK，拿到这样一个需求以后，我们先不要考虑今天要聊的享元模式，首要目标是解决需求，因为需求中虽然网站的发布形式不一样 ，但是基本的形式是一致的，所以最容易想到的方式是直接复制粘贴一份，然后根据客户不同要求，进行定制修改，接着，放到不同的虚拟空间中，如下示意图
方案分析
其实上面实现方式是我们经常用的，复制一份进行定制修改，就要求客户需要的网站结构相似度很高，只是展示的形式和部分微观结构需要定制，而且这些都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，会造成服务器的资源浪费
那其实我们可以考虑这样做，整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、CPU、数据库空间等服务器资源都尝试达成一个共享的效果，这样不仅减少了需要的服务器资源，而且对于代码来说，由于是一份实例，维护和扩展都更加容易，这种解决思路其实就是享元模式
基本介绍
享元模式（Flyweight Pattern）也叫蝇量模式：运用共享技术有效地支持大量细粒度的对象
属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式，享即共享，元即对象
常用于系统底层开发，解决系统的性能问题，像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则重新创建
再一个，享元模式能够解决重复对象的内存浪费的问题，当系统中有大量相似的对象，需要缓冲池时，不需要总是创建新对象，可以从缓存池里拿，这样可以降低系统内存，同时提高效率，所以，享元模式最经典的应用场景就是池技术了，String 常量池，数据库连接池，缓冲池等等都是享元模式的应用，享元模式是池技术的重要实现方式
原理类图
享元模式的类图如下图所示
享元模式角色分析
-
Flyweight 是抽象的享元角色，它是产品的抽象类，同时它会定义出对象的外部状态和内部状态
-
ConcreteFlyweight 是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
-
UnsharedConcreteFlyweight 是不可共享的角色，这个角色可能会出现在享元模式中，但是一般不会出现在享元工厂中
-
FlyweightFactory 是享元工厂类，用于构建一个池的容器（以集合的形式展现），同时提供从池中获取对象的相关方法
外部状态&内部状态
享元模式提出了两个要求，细粒度和共享对象，这里涉及到了两个概念，内部状态与外部状态，即将对象的信息分为两个部分，内部状态与外部状态
内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态
比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，所以棋子颜 色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，当我们落子后，落子颜色是定的，但位置是变化 的，所以棋子坐标就是棋子的外部状态
为什么要这样做
围棋理论上有 361 个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就减少了创建对象的数量，降低了重复对象的创建，减少内存占用和提高性能
解决方案二：享元模式
下面我们使用享元模式重构案例需求，首先我们通过类图来演示解决的思路
原理类图
代码演示
//抽象的享元角色
public abstract class Website {
public abstract void show(User user);//抽象方法
}
//具体的享元角色
public class ConcreteWebsite extends Website {
//共享的部分，不会变属于内部状态
private String type = "";//网站发布的形式
//构造器
public ConcreteWebsite(String type) {
this.type = type;
}
//外部状态？？例如用户
@Override
public void show(User user) {
System.out.println("以" + type + "形式发布网站项目,用户为：" + user.getName());
}
}
//享元工厂类
public class WebsiteFactory {
//创建集合，充当池的角色
private HashMap<String,ConcreteWebsite> pool = new HashMap<>();
//根据网站的类型，返回对应的网站，如果没有就创建网站并放入池中
public Website getWebsite(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 User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//客户端
public class Client {
public static void main(String[] args) {
//创建一个工厂
WebsiteFactory websiteFactory = new WebsiteFactory();
//客户要一个以新闻形式发布的网站
Website news = websiteFactory.getWebsite("news");
news.show(new User("老李"));
//客户需要以微信公众号形式发布的网站
Website wechat = websiteFactory.getWebsite("Wechat");
wechat.show(new User("老王"));
//多个客户需要微信公众号形式发布
Website wechat1 = websiteFactory.getWebsite("Wechat");
wechat1.show(new User("老赵"));
Website wechat2 = websiteFactory.getWebsite("Wechat");
wechat2.show(new User("老沈"));
//看看池子里的总数
System.out.println(websiteFactory.getWebsiteCount());
}
}注意事项
优势
-
节省内存空间，重复对象需要频繁被创建时，由于只会被创建一次，所以对系统内存的需求也大大减小
-
提高效率，对于可重复的对象只会被创建一次，再次访问时先从缓冲池中获取，响应速度更快，效率更高
注意点
享元模式提高了系统的复杂度，需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变，这是我们使用享元模式需要注意的地方,使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制，如果盲目使用， 会提高系统逻辑的复杂度
使用场景
-
享元模式经典的应用场景就是各类池技术
-
系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元模式用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用 HashMap/HashTable等来进行存储
Integer源码分析
OK，其实我们最常用的 java.lang.Integer 中，就使用到了享元模式，这节课我们一起来看下 Integer 源码中，享元模式的使用，在此之前呢，我们一起来聊几道 Integer 相关的面试，作为前置基础来引出我们要聊的内容
Int&Integer面试题解析
首先我们来看如下几个案例，对结果进行判定
Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false 由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）
Integer i = new Integer(100);
int j = 100;
System.out.print(i == j); //true Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）
Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false 非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）
Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueof(100);通过源码我们得知，默认对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，不会再次进行new操作
测试代码
OK，明确了上面的几点后，我们来看这样一段测试代码
public class Test {
public static void main(String[] args) {
Integer a = Integer.valueof(127);
Integer b = new Integer(127);
Integer c = Integer.valueof(127);
System.out.println(a.equals(b)); //比较大小，为true
System.out.println(a == b); //false
System.out.println(a == c); //true
}
}有了上面的前置基础，判断就很容易了，同时上面我们聊到，说对于传入的127会进行缓存，a是通过valueof方法传入127返回的对象实例，c也是如此，所以为true，下面我们通过源码来验证一下这个结论，而且同时大家也会想到，这其中就使用到了享元模式
Integer源码解析
我们进入 Integer 的 valueof 方法，如果在定义好的范围以内，会直接从下面的缓存池里去拿，如果不再该范围以内，return new Integer(i);
public static Integer valueof(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}默认定义好的范围是多少呢？我们接着往下看，默认缓存的范围是-128到127之间的数
也就是说，如果 Integer.valueOf(x) ，x满足这个范围，就是使用享元模式返回，而享元模式中，如果第一次没有，进行创建，有就直接返回，如果不在该范围，仍然创建一个新的对象
接着看，它在第一次创建 IntegerCache 的时候，首先创建了 cache 数组，大小为 (high - low) + 1，是因为数据下标不可以为负数，也就是创建了可以存放 -128 - 127 之间的数组，然后往里面一个个添加数据
valueOf 方法，就使用到享元模式，如果使用 valueOf 方法得到一个 Integer 实例，范围在 -128 - 127，直接返回已经创建好的，执行速度是要大于 new 操作的，当然，不光是 Integer 内部维护的缓冲池，String 常量池，数据库连接池，等等都是享元模式的应用，享元模式是池技术的重要实现方式
下节预告
OK，到这里，享元模式的相关内容就结束了，下一节，我们开启代理模式的学习，最后，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~
