关于java:设计模式之享元模式

41次阅读

共计 5964 个字符,预计需要花费 15 分钟才能阅读完成。

一、什么是享元模式

说到享元模式,第一个想到的应该就是池技术了,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     @Override
10     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     @Override
10     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 宝典

正文完
 0