泡图书馆，我想到了享元模式

大家好，我是老田，今天我给大家分享设计模式中的享元模式。用贴切的生活故事，以及真实项目场景来讲设计模式，最后用一句话来总结这个设计模式。

网站建设哪家好，找创新互联建站！专注于网页设计、网站建设、微信开发、微信小程序定制开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了广元免费建站欢迎大家使用！

下面是本文目录：

背景

享元模式(Flyweight Pattern)又叫作轻量级模式，是对象池的一种实现。

类似线程池，线程池可以避免不停地创建和销毁多个对象，消耗性能。

享元模式提供了减少对象数量从而改善应用所需的对象结构的方式。

英文解释：

Use sharing to support large numbers of fine-grained objects efficiently.

享元模式(Flyweight Pattern)其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者都创建一个单独的对象， 主要用于减少创建对象的数量，以减少内存占用和提高性能。

属于结构性设计模式，其中结构性设计模式有：代理、门面、装饰器、享元、桥接、适配器、组合。

注意：

享元模式把一个对象的状态分成内部状态和外部状态，内部状态是不变的，外部状态是变化的;然后通过共享不变的部分，达到减少对象数量并节约内存的目的。

生活案例

房屋中介

只要是个城市，就少不了房屋中介，房屋中介存有大量的出租房屋信息，并且一家房屋中介往往会有多个门店，但是所有门店都共享这些房屋信息(共享的是出租房屋的信息)。

个人身份证信息

每个中国公民都有一张身份证，并且这张身份证信息在公安系统中是共享的，全国各公安局派出所都会共享你的身份证信息(共享的是个人身份信息)。

高考志愿填报

每所大学在每个省都有明确的招收名额，这些名额对于该省的所有高考生而言都是共享的(共享的是招收名额)。

图书馆

图书馆里的可借书籍，对多有读者是共享的，大家都可以查询此书是否已经被借出去，还剩基本可借(共享的是图书)。

....

简单代码实现

下面我们通过一个案例来演示享元模式(图书馆为例)。

 
 
 
 
      
  
  
  
  1. public interface Book { 
    2.   
  
  
  
  2.     void borrow(); 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4. /** 
    5.   
  
  
  
  5.  * @author java后端技术全栈 
    6.   
  
  
  
  6.  */ 
    7.   
  
  
  
  7. public class ConcreteBook implements Book { 
    8.   
  
  
  
  8.     //被借出去的书名 
    9.   
  
  
  
  9.     private String name; 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.     public ConcreteBook(String name) { 
    12.   
  
  
  
  12.         this.name = name; 
    13.   
  
  
  
  13.     } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     @Override 
    16.   
  
  
  
  16.     public void borrow() { 
    17.   
  
  
  
  17.         System.out.println("图书馆借出去一本书，书名："+this.name); 
    18.   
  
  
  
  18.     } 
    19.   
  
  
  
  19. } 
    20.   
  
  
  
  20. import java.util.HashMap; 
    21.   
  
  
  
  21. import java.util.Map; 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. /** 图书馆 
    24.   
  
  
  
  24.  * @author java后端技术全栈 
    25.   
  
  
  
  25.  */ 
    26.   
  
  
  
  26. public class Llibrary { 
    27.   
  
  
  
  27.     private Map bookMap = new HashMap<>(); 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.     private Llibrary() { 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32.     //只能有一个图书馆 
    33.   
  
  
  
  33.     public static Llibrary getInstance() { 
    34.   
  
  
  
  34.         return LazyHolder.LAZY_STATIC_SINGLETON; 
    35.   
  
  
  
  35.     } 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.     //通过书名name来借书 
    38.   
  
  
  
  38.     public Book libToBorrow(String name) { 
    39.   
  
  
  
  39.         Book book; 
    40.   
  
  
  
  40.         //如果图书馆有，直接把书借走 
    41.   
  
  
  
  41.         if (bookMap.containsKey(name)) { 
    42.   
  
  
  
  42.             book = bookMap.get(name); 
    43.   
  
  
  
  43.         } else {//图书馆没有，则录入一本书，然后把书借走 
    44.   
  
  
  
  44.             book = new ConcreteBook(name); 
    45.   
  
  
  
  45.             bookMap.put(name, book); 
    46.   
  
  
  
  46.         } 
    47.   
  
  
  
  47.         return book; 
    48.   
  
  
  
  48.     } 
    49.   
  
  
  
  49.  
    50.   
  
  
  
  50.     //返回还有多少本书 
    51.   
  
  
  
  51.     public int bookSize() { 
    52.   
  
  
  
  52.         return bookMap.size(); 
    53.   
  
  
  
  53.     } 
    54.   
  
  
  
  54.     private static class LazyHolder { 
    55.   
  
  
  
  55.         private static final Llibrary LAZY_STATIC_SINGLETON = new Llibrary(); 
    56.   
  
  
  
  56.     } 
    57.   
  
  
  
  57. } 
    58.   
  
  
  
  58. import java.util.ArrayList; 
    59.   
  
  
  
  59. import java.util.List; 
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61. public class Student { 
    62.   
  
  
  
  62.     private static List bookList = new ArrayList<>(); 
    63.   
  
  
  
  63.     private static BookFactory bookFactory; 
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65.     public static void main(String[] args) { 
    66.   
  
  
  
  66.         bookFactory = BookFactory.getInstance(); 
    67.   
  
  
  
  67.  
    68.   
  
  
  
  68.         studenBorrow("java 从入门到精通"); 
    69.   
  
  
  
  69.         studenBorrow("java 从入门到放弃"); 
    70.   
  
  
  
  70.         studenBorrow("JVM java虚拟机"); 
    71.   
  
  
  
  71.         studenBorrow("java编程思想"); 
    72.   
  
  
  
  72.  
    73.   
  
  
  
  73.  
    74.   
  
  
  
  74.         //还了后，再借一次 
    75.   
  
  
  
  75.         studenBorrow("java 从入门到精通"); 
    76.   
  
  
  
  76.         studenBorrow("java 从入门到放弃"); 
    77.   
  
  
  
  77.         studenBorrow("JVM java虚拟机"); 
    78.   
  
  
  
  78.         studenBorrow("java编程思想"); 
    79.   
  
  
  
  79.  
    80.   
  
  
  
  80.         //还了后，再借一次 
    81.   
  
  
  
  81.         studenBorrow("java 从入门到精通"); 
    82.   
  
  
  
  82.         studenBorrow("java 从入门到放弃"); 
    83.   
  
  
  
  83.         studenBorrow("JVM java虚拟机"); 
    84.   
  
  
  
  84.         studenBorrow("java编程思想"); 
    85.   
  
  
  
  85.  
    86.   
  
  
  
  86.         //把每一本书借出去 
    87.   
  
  
  
  87.         for (Book book:bookList){ 
    88.   
  
  
  
  88.             book.borrow(); 
    89.   
  
  
  
  89.         } 
    90.   
  
  
  
  90.  
    91.   
  
  
  
  91.         System.out.println("学生一共借了 "+bookList.size()+"本书"); 
    92.   
  
  
  
  92.         System.out.println("学生一共借了 "+ bookFactory.bookSize()+"本书"); 
    93.   
  
  
  
  93.  
    94.   
  
  
  
  94.     } 
    95.   
  
  
  
  95.  
    96.   
  
  
  
  96.     private static void studenBorrow(String name) { 
    97.   
  
  
  
  97.         bookList.add(bookFactory.libToBorrow(name)); 
    98.   
  
  
  
  98.     } 
    99.   
  
  
  
  99. } 
    100.

运行结果

 
 
 
 
      
  
  
  
  1. 图书馆借出去一本书，书名：java 从入门到精通 
    2.   
  
  
  
  2. 图书馆借出去一本书，书名：java 从入门到放弃 
    3.   
  
  
  
  3. 图书馆借出去一本书，书名：JVM java虚拟机 
    4.   
  
  
  
  4. 图书馆借出去一本书，书名：java编程思想 
    5.   
  
  
  
  5. 图书馆借出去一本书，书名：java 从入门到精通 
    6.   
  
  
  
  6. 图书馆借出去一本书，书名：java 从入门到放弃 
    7.   
  
  
  
  7. 图书馆借出去一本书，书名：JVM java虚拟机 
    8.   
  
  
  
  8. 图书馆借出去一本书，书名：java编程思想 
    9.   
  
  
  
  9. 图书馆借出去一本书，书名：java 从入门到精通 
    10.   
  
  
  
  10. 图书馆借出去一本书，书名：java 从入门到放弃 
    11.   
  
  
  
  11. 图书馆借出去一本书，书名：JVM java虚拟机 
    12.   
  
  
  
  12. 图书馆借出去一本书，书名：java编程思想 
    13.   
  
  
  
  13. 学生一共借了 12本书 
    14.   
  
  
  
  14. 学生一共借了 4本书 
    15.

其实，图书馆只有四本书，但是多个人借，A借来看完了，B再去借，B还了C再去借。

这些书籍就被大家共享了。

享元模式的UML类图如下：

由上图可以看到，享元模式主要包含3个角色。

  • 抽象享元角色(Book)：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现。
  • 具体享元角色(ConcreteBook)：实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不会出现一个操作改变内部状态、同时修改了外部状态的情况。
  • 享元工厂(BookFactory)：负责管理享元对象池和创建享元对象。

也许这个例子你还是不太明白，下面我们就用工作中常见的场景来解释一通。

大佬们是怎样使用的

关于享元模式，在JDK中大量的使用，比如：String、Integer、Long等类中，都有使用到。

Integer中的享元模式

下面这段代码输出什么?

 
 
 
 
      
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 欢迎关注公众号：java后端技术全栈 
    3.   
  
  
  
  3.  * 
    4.   
  
  
  
  4.  * @author 田维常 
    5.   
  
  
  
  5.  * @date 2021/06/02 19:30 
    6.   
  
  
  
  6.  */ 
    7.   
  
  
  
  7. public class IntegerDemo { 
    8.   
  
  
  
  8.     public static void main(String[] args) { 
    9.   
  
  
  
  9.         Integer a = 100; 
    10.   
  
  
  
  10.         Integer b = Integer.valueOf(100); 
    11.   
  
  
  
  11.         System.out.println(a == b); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         Integer c = new Integer(1000); 
    14.   
  
  
  
  14.         Integer d = Integer.valueOf(1000); 
    15.   
  
  
  
  15.         System.out.println(c == d); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18. } 
    19.

很多人可能会认为输出

 
 
 
 
      
  
  
  
  1. true 
    2.   
  
  
  
  2. true 
    3.

其实，非也，这里最终输出的是：

 
 
 
 
      
  
  
  
  1. true 
    2.   
  
  
  
  2. false 
    3.

为什么呢?100就可以比较，1000就不能比较了?

其实，在Integer里就用到了享元模式，它就是把-128到127这个范围的数据缓存起来(放在Integer类型的数组中)。

 
 
 
 
      
  
  
  
  1. static final int low = -128; 
    2.   
  
  
  
  2. public static Integer valueOf(int i) { 
    3.   
  
  
  
  3.     //high默认是127 
    4.   
  
  
  
  4.     if (i >= IntegerCache.low && i <= IntegerCache.high) 
    5.   
  
  
  
  5.         return IntegerCache.cache[i + (-IntegerCache.low)]; 
    6.   
  
  
  
  6.     return new Integer(i); 
    7.   
  
  
  
  7. } 
    8.

下面进行一个简要的分析：

关于Integer的缓存，推荐看这篇文章：

这里Integer里的IntegerCache里就用到了享元模式。

关于Integer 推荐：面试官：说说Integer缓存范围

String中的享元模式

Java中讲String类定义为final不能继承，并且将属性value也定义为final便是不可变，JVM中字符串一般保存在字符串常量池中，Java会确保一个字符串在常量池中只会有一份拷贝，这个字符串常量池在JDK1.6中位于方法区(永久代)中，而JDK1.7以后，JVM讲其从方法区移动到了堆heap中。

下面这段代码输出什么?

 
 
 
 
      
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 欢迎关注公众号：java后端技术全栈 
    3.   
  
  
  
  3.  * 
    4.   
  
  
  
  4.  * @author 田维常 
    5.   
  
  
  
  5.  * @date 2021/06/03 
    6.   
  
  
  
  6.  */ 
    7.   
  
  
  
  7. public class StringDemo { 
    8.   
  
  
  
  8.     public static void main(String[] args) throws Exception { 
    9.   
  
  
  
  9.         String s1 = "abcd"; 
    10.   
  
  
  
  10.         String s2 = "abcd"; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         String s3 = "ab" + "cd"; 
    14.   
  
  
  
  14.         String s4 = "ab" + new String("cd"); 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         String s5 = new String("abcd"); 
    17.   
  
  
  
  17.         String s6 = s5.intern(); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.         String s7 = "a"; 
    20.   
  
  
  
  20.         String s8 = "bcd"; 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         String s9 = s7 + s8; 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         System.out.println("s1 == s2 " + (s1 == s2)); 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.         System.out.println("s1 == s3 " + (s1 == s3)); 
    27.   
  
  
  
  27.         System.out.println("s1 == s4 " + (s1 == s4)); 
    28.   
  
  
  
  28.         System.out.println("s1 == s6 " + (s1 == s6)); 
    29.   
  
  
  
  29.         System.out.println("s1 == s9 " + (s1 == s9)); 
    30.   
  
  
  
  30.         System.out.println("s4 == s5 " + (s4 == s5)); 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33. } 
    34.

String类中的value是final修饰的，以字面量的形式创建String变量时，JVM会在编译期间就把该字面量“abcd”放到字符串常量池汇总，有Java程序启动的时候就已经加载到内存中了。这个字符串常量的特点就是有且仅有一份相同的字面量，如果其他相同字面量，JVM则返回这个字面量的引用，如果没有相同的字面量，则再字符串常量池中创建这个字面量并返回它的引用。

由于s2指向字面量"abcd"在常量池中已经存在了(s1先于s2)，于是JVM就返回这个字面量绑定的引用，所以s1==s2。

s3中字面量的拼接其实在JVM层已经做了优化，在JVM编译期间就对s3的拼接做了优化，所以s1、s2、s3都可以理解为是同一个，即s1==s3。

s4中的new String("cd")，此时生成了两个对象，"cd"和new String("cd")，"cd"存在于字符串常量池中，new String("cd")存在于堆heap中，String s4="ab"+ new String("cd");实质上是两个对象的相加，编译器不会对其进行优化，相加的结果存在于堆heap中，而s2存在于字符串常量池中，当然不相等，即s1!=s4。

s4和s5最终的结果都是在堆中，所以此时s4!=s5

s5.intern()方法能是一个维度对总的字符串在运行期间动态地加入到字符串常量池中(字符串常量池的内容是程序启动的时候就以及酒精加载好了，如果字符串常量池中存在该对象对应的字面量，则返回该字面量在字符串常量池中的引用，否则，创建复制一份该字面量到字符串常量池中并发那会它的引用)，因此s1==s6。

s9是s7和s8拼接而成，但是jvm并没有对其进行优化，所以s1!=s9

最后，上面这段代码输出：

 
 
 
 
      
  
  
  
  1. s1 == s2 true 
    2.   
  
  
  
  2. s1 == s3 true 
    3.   
  
  
  
  3. s1 == s4 false 
    4.   
  
  
  
  4. s1 == s6 true 
    5.   
  
  
  
  5. s1 == s9 false 
    6.   
  
  
  
  6. s4 == s5 false 
    7.

JVM中的常量池也是享元模式的经典实现之一。

关于String延伸内容：

美团面试题：String s = new String("111")会创建几个对象?

Long中的享元模式

Long中和Integer中类似，也是最-128到127的数进行了缓存，请看Long中的valueOf()方法源码部分：

 
 
 
 
      
  
  
  
  1. public static Long valueOf(long l) { 
    2.   
  
  
  
  2.     final int offset = 128; 
    3.   
  
  
  
  3.     if (l >= -128 && l <= 127) { // will cache 
    4.   
  
  
  
  4.         return LongCache.cache[(int)l + offset]; 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.     return new Long(l); 
    7.   
  
  
  
  7. } 
    8.

这个就没必要进行演示了，和Integer一样，都是使用了缓存，也就是享元模式。

在Apache Commons Pool中的享元模式

对象池化的基本思路是：将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象造成的消耗。用于充当保存对象的“容器”的对象，被称为对象池(Object Pool，简称Pool)。

Apache Pool实现了对象池的功能，定义了对象的生成、销毁、激活、钝化等操作及其状态转换，并提供几个默认的对象池实现，

有如下几个重要的角色：

  • Pooled Object(池化对象)：用于封装对象(例如，线程、数据库连接和TCP连接)，将其包裹成可被对象池管理的对象。
  • Pooled Object Factory(池化对象工厂)：定义了操作Pooled Object实例生命周期的一些方法，Pooled Object Factory必须实现线程安全。
  • Object Pool(对象池)：Object Pool负责管理Pooled Object，例如，借出对象、返回对象、校验对象、有多少激活对象和有多少空闲对象。

在ObjectPool类的子类org.apache.commons.pool2.impl.GenericObjectPool种有个属性：

 
 
 
 
      
  
  
  
  1. private final Map, PooledObject> allObjects; 
    2.

这个Map就是用来缓存对象的，所以这里也是享元模式的实现。

享元模式的扩展

享元模式中的状态

享元模式的定义提出了两个要求：细粒度和共享对象。

因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

内部状态指对象共享出来的信息，存储在享元对象内部，并且不会随环境的改变而改变;

外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

比如：连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

优缺点

优点

  • 减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率。
  • 减少内存之外的其他资源占用。

缺点

  • 关注内、外部状态，关注线程安全问题。
  • 使系统、程序的逻辑复杂化。

总结

享元模式，单从概念来讲估计很多人不是很理解，但是从Integer、String已经生活中的场景结合起来理解，就能轻松理解享元模式，享元模式的实现基本上都伴随着一个集合用来存这些对象。

一句话总结：

优化资源配置，减少资源浪费

参考：Tom的设计模式课程

好了，今天的分享就到此结束，希望大家能明白什么是享元模式，享元模式的思想我们在开发中是否能借鉴，面试的时候就不要再说你不会设计模式了。

本文转载自微信公众号「Java后端技术全栈」，可以通过以下二维码关注。转载本文请联系Java后端技术全栈公众号。

文章题目：泡图书馆，我想到了享元模式
URL分享：http://www.shufengxianlan.com/qtweb/news38/264488.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

响应式网站知识

各行业网站

成都响应式网站建设　　 　优化排名　　 　小谭网创广告　　 　抖音短视频　　 　芦山网站建设　　 　江安网站建设　　 　普格博源建站　　 　成都木托盘　　 　移动手机网站制作　　 　成都标识标牌设计制作　　 　成都网络公司　　 　贵阳托管服务器　　 　ssl证书申请　　 　网站托管运营　　 　成都画册制作　　 　玄科环保　　 　自贡服务器托管　　 　app软件开发　　 　四川航空文化　　 　西云服务器托管