说到享元模式,第一个想到的应该就是池技术了,String常量池、数据库链接池、缓冲池等等都是享元模式的应用,因此说享元模式是池技术的重要实现方式。数据库
好比咱们每次建立字符串对象时,都须要建立一个新的字符串对象的话,内存开销会很大,因此若是第一次建立了字符串对象“adam“,下次再建立相同的字符串”adam“时,只是把它的引用指向”adam“,这样就实现了”adam“字符串再内存中的共享。安全
举个最简单的例子,网络联机下棋的时候,一台服务器链接了多个客户端(玩家),若是咱们每一个棋子都要建立对象,那一盘棋可能就有上百个对象产生,玩家多点的话,由于内存空间有限,一台服务器就难以支持了,因此这里要使用享元模式,将棋子对象减小到几个实例。下面给出享元模式的定义。bash
享元模式(Flyweight),运用共享技术有效地支持大量细粒度的对象。UML结构图以下:服务器
其中,Flyweight是抽象享元角色。它是产品的抽象类,同时定义出对象的外部状态和内部状态(外部状态及内部状态相关内容见后方)的接口或实现;ConcreteFlyweight是具体享元角色,是具体的产品类,实现抽象角色定义的业务;UnsharedConcreteFlyweight是不可共享的享元角色,通常不会出如今享元工厂中;FlyweightFactory是享元工厂,它用于构造一个池容器,同时提供从池中得到对象的方法。网络
全部具体享元类的超类或接口,经过这个接口,Flyweight能够接受并做用于外部状态。ide
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 }复制代码
继承Flyweight超类或实现Flyweight接口,并为其内部状态增长存储空间。性能
1 public class ConcreteFlyweight extends Flyweight {
2
3 //接受外部状态
4 public ConcreteFlyweight(String extrinsic) {
5 super(extrinsic);
6 }
7
8 //根据外部状态进行逻辑处理
9 @Override
10 public void operate(int extrinsic) {
11 System.out.println("具体Flyweight:" + extrinsic);
12 }
13
14 }复制代码
指那些不须要共享的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 }复制代码
一个享元工厂,用来建立并管理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 }复制代码
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 }复制代码
运行结果以下:ui
从这个结果咱们能够看出来,第一次建立X、Y、Z时,都是先建立再从池中取出,而第二次建立X时,由于池中已经存在了,因此直接从池中取出,这就是享元模式。
上面享元模式的定义为咱们提出了两个要求:细粒度和共享对象。咱们知道分配太多的对象到应用程序中将有损程序的性能,同时还容易形成内存溢出,要避免这种状况,用到的就是共享技术,这里就须要提到内部状态和外部状态了。
由于要求细粒度对象,因此不可避免地会使对象数量多且性质相近,此时咱们就将这些对象的信息分为两个部分:内部状态和外部状态。
内部状态指对象共享出来的信息,存储在享元对象内部而且不会随环境的改变而改变;外部状态指对象得以依赖的一个标记,是随环境改变而改变的、不可共享的状态。
咱们举一个最简单的例子,棋牌类游戏你们都有玩过吧,好比说说围棋和跳棋,它们都有大量的棋子对象,围棋和五子棋只有黑白两色,跳棋颜色略多一点,但也是不太变化的,因此棋子颜色就是棋子的内部状态;而各个棋子之间的差异就是位置的不一样,咱们落子嘛,落子颜色是定的,但位置是变化的,因此方位坐标就是棋子的外部状态。
那么为何这里要用享元模式呢?能够想象一下,上面提到的棋类游戏的例子,好比围棋,理论上有361个空位能够放棋子,常规状况下每盘棋都有可能有两三百个棋子对象产生,由于内存空间有限,一台服务器很难支持更多的玩家玩围棋游戏,若是用享元模式来处理棋子,那么棋子对象就能够减小到只有两个实例,这样就很好的解决了对象的开销问题。
应用实例的话,其实上面的模板就已是一个很好的例子了,相似于String常量池,没有的对象建立后存在池中,若池中存在该对象则直接从池中取出。
为了更好的理解享元模式,这里再举一个实例,好比接了我一个小型的外包项目,是作一个产品展现网站,后来他的朋友们也但愿作这样的网站,但要求都有些不一样,咱们固然不能直接复制粘贴再来一份,有任但愿是新闻发布形式的,有人但愿是博客形式的等等,并且由于经费缘由不能每一个网站租用一个空间。
其实这里他们须要的网站结构类似度很高,并且都不是高访问量网站,若是分红多个虚拟空间来处理,至关于一个相同网站的实例对象不少,这是形成服务器的大量资源浪费。若是整合到一个网站中,共享其相关的代码和数据,那么对于硬盘、内存、CPU、数据库空间等服务器资源均可以达成共享,减小服务器资源;而对于代码,因为是一份实例,维护和扩展都更加容易。
那么此时就能够用到享元模式了。UML图以下:
1 public abstract class WebSite {
2
3 public abstract void use();
4
5 }复制代码
1 public class ConcreteWebSite extends WebSite {
2
3 private String name = "";
4
5 public ConcreteWebSite(String name) {
6 this.name = name;
7 }
8
9 @Override
10 public void use() {
11 System.out.println("网站分类:" + name);
12 }
13
14 }复制代码
这里使用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 }复制代码
这里测试用例给了两种网站,原先咱们须要作三个产品展现和三个博客的网站,也即须要六个网站类的实例,但其实它们本质上都是同样的代码,能够利用用户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个。这样基本算是实现了享元模式的共享对象的目的,但想一想上面提到的内部状态和外部状态,这里实际上没有体现对象间的不一样,只体现了它们的共享部分。
因此咱们再加一个用户类,做为网站类的外部状态,并在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"));
(具体内容可参考源码,源码地址见最下方)
运行结果以下:
这样就能够协调内部与外部状态,哪怕接手了上千个网站的需求,只要要求相同或相似,实际开发代码也就是分类的哪几种。