一、什么是享元模式
说到享元模式，第一个想到的应该就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的利用，所以说享元模式是池技术的重要实现形式。
比方咱们每次创立字符串对象时，都须要创立一个新的字符串对象的话，内存开销会很大，所以如果第一次创立了字符串对象“adam“，下次再创立雷同的字符串”adam“时，只是把它的援用指向”adam“，这样就实现了”adam“字符串再内存中的共享。
举个最简略的例子，网络联机下棋的时候，一台服务器连贯了多个客户端（玩家），如果咱们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间无限，一台服务器就难以反对了，所以这里要应用享元模式，将棋子对象缩小到几个实例。上面给出享元模式的定义。
享元模式（Flyweight），使用共享技术无效地反对大量细粒度的对象。UML结构图如下：
其中，Flyweight是形象享元角色。它是产品的抽象类，同时定义出对象的内部状态和外部状态（内部状态及外部状态相干内容见前方）的接口或实现；ConcreteFlyweight是具体享元角色，是具体的产品类，实现形象角色定义的业务；UnsharedConcreteFlyweight是不可共享的享元角色，个别不会呈现在享元工厂中；FlyweightFactory是享元工厂，它用于结构一个池容器，同时提供从池中取得对象的办法。
1. Flyweight抽象类
所有具体享元类的超类或接口，通过这个接口，Flyweight能够承受并作用于内部状态。
1 public abstract class Flyweight { 2 3 //外部状态 4 public String intrinsic; 5 //内部状态 6 protected final String extrinsic; 7 8 //要求享元角色必须承受内部状态 9 public Flyweight(String extrinsic) {10 this.extrinsic = extrinsic;11 }12 13 //定义业务操作14 public abstract void operate(int extrinsic);15 16 public String getIntrinsic() {17 return intrinsic;18 }19 20 public void setIntrinsic(String intrinsic) {21 this.intrinsic = intrinsic;22 }23 24 }2. ConcreteFlyweight类
继承Flyweight超类或实现Flyweight接口，并为其外部状态减少存储空间。
1 public class ConcreteFlyweight extends Flyweight { 2 3 //承受内部状态 4 public ConcreteFlyweight(String extrinsic) { 5 super(extrinsic); 6 } 7 8 //依据内部状态进行逻辑解决 9 @Override10 public void operate(int extrinsic) {11 System.out.println("具体Flyweight:" + extrinsic);12 }13 14 }3. UnsharedConcreteFlyweight类
指那些不须要共享的Flyweight子类。
1 public class UnsharedConcreteFlyweight extends Flyweight { 2 3 public UnsharedConcreteFlyweight(String extrinsic) { 4 super(extrinsic); 5 } 6 7 @Override 8 public void operate(int extrinsic) { 9 System.out.println("不共享的具体Flyweight:" + extrinsic);10 }11 12 }4. FlyweightFactory类
一个享元工厂，用来创立并治理Flyweight对象，次要是用来确保正当地共享Flyweight，当用户申请一个Flyweight时，FlyweightFactory对象提供一个已创立的实例或创立一个实例。
1 public class FlyweightFactory { 2 3 //定义一个池容器 4 private static HashMap<String, Flyweight> pool = new HashMap<>(); 5 6 //享元工厂 7 public static Flyweight getFlyweight(String extrinsic) { 8 Flyweight flyweight = null; 9 10 if(pool.containsKey(extrinsic)) { //池中有该对象11 flyweight = pool.get(extrinsic);12 System.out.print("已有 " + extrinsic + " 间接从池中取---->");13 } else {14 //依据内部状态创立享元对象15 flyweight = new ConcreteFlyweight(extrinsic);16 //放入池中17 pool.put(extrinsic, flyweight);18 System.out.print("创立 " + extrinsic + " 并从池中取出---->");19 }20 21 return flyweight;22 }23 }5. Client客户端
1 public class Client { 2 3 public static void main(String[] args) { 4 int extrinsic = 22; 5 6 Flyweight flyweightX = FlyweightFactory.getFlyweight("X"); 7 flyweightX.operate(++ extrinsic); 8 9 Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");10 flyweightY.operate(++ extrinsic);11 12 Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");13 flyweightZ.operate(++ extrinsic);14 15 Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");16 flyweightReX.operate(++ extrinsic);17 18 Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");19 unsharedFlyweight.operate(++ extrinsic);20 }21 22 }运行后果如下：
从这个后果咱们能够看进去，第一次创立X、Y、Z时，都是先创立再从池中取出，而第二次创立X时，因为池中曾经存在了，所以间接从池中取出，这就是享元模式。
二、外部状态和内部状态
下面享元模式的定义为咱们提出了两个要求：细粒度和共享对象。咱们晓得调配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，要防止这种状况，用到的就是共享技术，这里就须要提到外部状态和内部状态了。
因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时咱们就将这些对象的信息分为两个局部：外部状态和内部状态。
外部状态指对象共享进去的信息，存储在享元对象外部并且不会随环境的扭转而扭转；内部状态指对象得以依赖的一个标记，是随环境扭转而扭转的、不可共享的状态。
咱们举一个最简略的例子，棋牌类游戏大家都有玩过吧，比如说说围棋和跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋色彩略多一点，但也是不太变动的，所以棋子色彩就是棋子的外部状态；而各个棋子之间的差异就是地位的不同，咱们落子嘛，落子色彩是定的，但地位是变动的，所以方位坐标就是棋子的内部状态。
那么为什么这里要用享元模式呢？能够设想一下，下面提到的棋类游戏的例子，比方围棋，实践上有361个空位能够放棋子，惯例状况下每盘棋都有可能有两三百个棋子对象产生，因为内存空间无限，一台服务器很难反对更多的玩家玩围棋游戏，如果用享元模式来解决棋子，那么棋子对象就能够缩小到只有两个实例，这样就很好的解决了对象的开销问题。
三、享元模式的利用
1. 何时应用
- 零碎中有大量对象时
- 这些对象耗费大量内存时
- 这些对象的状态大部分能够内部化时
2. 办法
- 用惟一标识码判断，如果在内存中有，则返回这个惟一标识码所标识的对象，用HashMap/HashTable存储
3. 长处
- 大大减少了对象的创立，升高了程序内存的占用，提高效率
4. 毛病
- 进步了零碎的复杂度。须要拆散出外部状态和内部状态，而内部状态具备固化个性，不应该随着外部状态的扭转而扭转
5. 应用场景
- 零碎中存在大量类似对象
- 须要缓冲池的场景
6. 利用实例
- String常量池
- 数据库连接池
7. 注意事项
- 留神划分外部状态和内部状态，否则可能会引起线程平安问题
- 这些类必须有一个工厂类加以控制
四、享元模式的实现
利用实例的话，其实下面的模板就曾经是一个很好的例子了，相似于String常量池，没有的对象创立后存在池中，若池中存在该对象则间接从池中取出。
为了更好的了解享元模式，这里再举一个实例，比方接了我一个小型的外包我的项目，是做一个产品展现网站，起初他的敌人们也心愿做这样的网站，但要求都有些不同，咱们当然不能间接复制粘贴再来一份，有任心愿是新闻公布模式的，有人心愿是博客模式的等等，而且因为经费起因不能每个网站租用一个空间。
其实这里他们须要的网站构造类似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来解决，相当于一个雷同网站的实例对象很多，这是造成服务器的大量资源节约。如果整合到一个网站中，共享其相干的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都能够达成共享，缩小服务器资源；而对于代码，因为是一份实例，保护和扩大都更加容易。
那么此时就能够用到享元模式了。UML图如下：
1. 网站抽象类
1 public abstract class WebSite {2 3 public abstract void use();4 5 }2. 具体网站类
1 public class ConcreteWebSite extends WebSite { 2 3 private String name = ""; 4 5 public ConcreteWebSite(String name) { 6 this.name = name; 7 } 8 9 @Override10 public void use() {11 System.out.println("网站分类：" + name);12 }13 14 }3. 网络工厂类
这里应用HashMap来作为池，通过put和get办法实现退出池与从池中取的操作。
1 public class WebSiteFactory { 2 3 private HashMap<String, ConcreteWebSite> pool = new HashMap<>(); 4 5 //取得网站分类 6 public WebSite getWebSiteCategory(String key) { 7 if(!pool.containsKey(key)) { 8 pool.put(key, new ConcreteWebSite(key)); 9 }10 11 return (WebSite)pool.get(key);12 }13 14 //取得网站分类总数15 public int getWebSiteCount() {16 return pool.size();17 }18 19 }4. Client客户端
这里测试用例给了两种网站，原先咱们须要做三个产品展现和三个博客的网站，也即须要六个网站类的实例，但其实它们实质上都是一样的代码，能够利用用户ID号的不同，来辨别不同的用户，具体数据和模板能够不同，但代码外围和数据库却是共享的。
1 public class Client { 2 3 public static void main(String[] args) { 4 WebSiteFactory factory = new WebSiteFactory(); 5 6 WebSite fx = factory.getWebSiteCategory("产品展现"); 7 fx.use(); 8 9 WebSite fy = factory.getWebSiteCategory("产品展现");10 fy.use();11 12 WebSite fz = factory.getWebSiteCategory("产品展现");13 fz.use();14 15 WebSite fa = factory.getWebSiteCategory("博客");16 fa.use();17 18 WebSite fb = factory.getWebSiteCategory("博客");19 fb.use();20 21 WebSite fc = factory.getWebSiteCategory("博客");22 fc.use();23 24 System.out.println("网站分类总数为：" + factory.getWebSiteCount());25 }26 27 }运行后果如下：
能够看出，尽管咱们做了6个网站，但网站分类只有2个。这样根本算是实现了享元模式的共享对象的目标，但想想下面提到的外部状态和内部状态，这里实际上没有体现对象间的不同，只体现了它们的共享局部。
5. 用户类
所以咱们再加一个用户类，作为网站类的内部状态，并在use()办法中传递用户对象，UML如下：
上面增加一个User类。
1 public class User { 2 3 private String name; 4 5 public User(String name) { 6 this.name = name; 7 } 8 9 public String getName() {10 return name;11 }12 13 }而后再对use()办法进行批改，增加参数，以抽象类为例： public abstract void use(User user);
而客户端中只需对每一个网站增加一个用户即可，如： fx.use(new User("adam"));
（具体内容可参考源码，源码地址见最下方）
运行后果如下：
这样就能够协调外部与内部状态，哪怕接手了上千个网站的需要，只有要求雷同或相似，理论开发代码也就是分类的哪几种。
关注公众号:java宝典