设计模式——享元模式

一、基本介绍

1、享元模式（Flyweight Pattern）也叫 “蝇量模式”：运用共享技术有效地支持大量细粒度对象。
2、常用于系统底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿过来用，避免重新创建，如果没有我们需要的，则创建一个。
3、享元模式能够解决重复对象的内存消耗问题，当系统中有大量相似对象，需要缓冲池时。不需要总创建新对象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率。
4、享元模式经典的应用的场景就是池技术，String 常量池、数据库连接池、缓冲池等等都是享元模式的应用，享元模式是池技术的重要实现方式。

二、享元模式的特点

享元模式的主要优点：相同对象只要保存一份，降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
享元模式的主要缺点：为了使对象共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。需要分离出外部状态和内部状态，而且外部状态具有固有化性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。
享元模式的主要意图：运行享元模式有效地支持大量细粒度对象。
享元模式主要解决的问题：在有大量相似对象时，有可能会造成内存溢出，我们把其中共同的部分抽取出来，如果有相同的业务请求，直接返回内存中已有的对象，避免重新创建。
享元模式如何解决问题：用唯一标识码判断，如果内存中有，则返回唯一标识所标识的对象。
享元模式关键代码：用 HashMap 存储对象，key 表示唯一标识，value 为共享对象。
享元模式使用场景：1）、系统有大量相似对象。2）、需要缓冲池的场景。
享元模式注意事项：1）、注意划分外部状态和内部状态，否则可能会引起线程安全问题。2）、这些类必须有一个工厂对象加以控制。

三、内部状态和外部状态

1）、享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态，既将对象的信息分为两部分：内部状态和外部状态。
2）、内部状态：指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变。
3）、外部状态：指对象得以依赖的一个标记，是随环境改变而改变的，不可共享的状态。

四、享元模式结构类图

享元模式的主要角色如下：
1）、抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
2）、具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
3）、非享元（Unsharalbe Flyweight）角色：是不可以共享的外部状态，它以参数的形式注入具有享元的相关方法中。
4）、享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在，则创建一个新的享元对象。

五、享元模式案例分析

享元模式在五子棋中的应用：包含多个内部状态 “黑” 和 “白” 颜色的棋子和外部状态棋子的坐标，所以适合享元模式、

【1】抽象享元角色：棋子（ChessPieces）类包含了一个落子的方法：downPieces(Point pt)

1 public interface ChessPieces {
2     //落子方法 color:内部状态  pt：外部状态
3     public void downPieces(Point pt);
4 }

【2】具体享元角色：抽象享元角色的实现类（黑子/白子的实现类）

☛ 黑子实现类如下：

1 public class BlackPieces implements ChessPieces{
2     @Override
3     public void downPieces(Point pt) {
4         System.out.println("当前获取到的为===黑===颜色的棋子");
5         System.out.println("坐标X="+pt.getX()+";Y="+pt.getY());
6     }
7 }

☞ 白子实现类如下：

1 public class WhitePieces implements ChessPieces{
2     @Override
3     public void downPieces(Point pt) {
4         System.out.println("当前获取到的为===白===颜色的棋子");
5         System.out.println("坐标X="+pt.getX()+";Y="+pt.getY());
6     }
7 }

【3】享元工厂角色：通过内部状态，将对象进行分类存储，相同的内部状态只存一个对象即可。

 1 public class PiecesFactory {
 2     //存储已创建的棋子   享元模式的精华
 3     HashMap<String, ChessPieces> pieces = new HashMap<>();
 4     private final String WRITE = "Write";
 5     private final String BLACK = "Black";
 6     //创建一个静态方法 获取棋子对象
 7     public ChessPieces getPieceInstance(String color) {
 8         if(pieces.get(color) == null) {
 9             if(color == WRITE) {
10                 WhitePieces whitePieces = new WhitePieces();
11                 pieces.put(color, whitePieces);
12             }else if(color == BLACK){
13                 BlackPieces blackPieces = new BlackPieces();
14                 pieces.put(color, blackPieces);
15             }else {
16                 System.out.println("不存在的颜色");
17                 return null;
18             }
19         }
20         return pieces.get(color);
21     }
22     
23     //查看 hashmap 中总计的实例数量
24     public int getInstallCount() {
25         return pieces.size();
26     }
27 }

【4】客户端应用：将内部状态传递给工厂类，外部状态传递给具体实现类。

 1 public class Clinet {
 2     private final static String WRITE = "Write";
 3     private final static String BLACK = "Black";
 4     
 5     public static void main(String[] args) {
 6         //创建工程
 7         PiecesFactory factory = new PiecesFactory();
 8         //获取白色棋子
 9         //下琪1 = 白
10         ChessPieces piece1 = factory.getPieceInstance(WRITE);
11         piece1.downPieces(new Point(1,2));
12         //下琪1 = 黑
13         ChessPieces pieceB1 = factory.getPieceInstance(BLACK);
14         pieceB1.downPieces(new Point(2,2));
15         //下琪2 = 白
16         ChessPieces piece2 = factory.getPieceInstance(WRITE);
17         piece2.downPieces(new Point(2, 3));
18         //下琪2 = 黑
19         ChessPieces pieceB2 = factory.getPieceInstance(BLACK);
20         pieceB2.downPieces(new Point(3,2));
21         //下琪3 = 白
22         ChessPieces piece3 = factory.getPieceInstance(WRITE);
23         piece3.downPieces(new Point(5, 7));
24         //下琪3 = 黑
25         ChessPieces pieceB3 = factory.getPieceInstance(BLACK);
26         pieceB3.downPieces(new Point(6,6));
27         
28         /**
29          * 结果：
30          * 当前获取到的为===白===颜色的棋子
31          * 坐标X=1;Y=2
32          * 当前获取到的为===黑===颜色的棋子
33          * 坐标X=2;Y=2
34          * 当前获取到的为===白===颜色的棋子
35          * 坐标X=2;Y=3
36          * 当前获取到的为===黑===颜色的棋子
37          * 坐标X=3;Y=2
38          * 当前获取到的为===白===颜色的棋子
39          * 坐标X=5;Y=7
40          * 当前获取到的为===黑===颜色的棋子
41          * 坐标X=6;Y=6
42          */
43         
44         //重点是,这6颗棋子 总共创建了多少个对象
45         System.out.println(factory.getInstallCount());
46         /**
47          * 输入结果：2   复合享元模式的应用
48          */
49     }
50 }

六、享元模式 JDK-Interger 应用源码分析

【1】我们在创建 Interger 对象时，有两种方式：分别是 valueOf() 和 new 的形式，如下：我们会发现 valueOf() 创建的实例是相等的，说明使用了享元模式，下面我们就查看下其源码：

 1 public static void main(String[] args) {
 2         Integer x = Integer.valueOf(127); // 得到 x实例，类型 Integer
 3         Integer y = new Integer(127); // 得到 y 实例，类型 Integer
 4         Integer z = Integer.valueOf(127);//..
 5         Integer w = new Integer(127);
 6                 
 7         //我们会发现valueOf创建的实例是相等的，说明使用了享元模式。new 每次给创建一个新的对象
 8         System.out.println(x == z ); // true
 9         System.out.println(w == y ); // false
10     }

【2】进入 valueOf 方法：根据源码分析：只有当 -128 <= i >= 127 时，就使用享元模式，从缓存中获取值

 1 public static Integer valueOf(int i) {
 2     /**
 3      * IntegerCache.low = -128
 4      * IntegerCache.highhigh = 127
 5      * 根据源码分析：只有当 -128 <= i >= 127 时，就使用享元模式，从缓存中获取值
 6      * IntegerCache 相当于工厂类
 7      */
 8     if (i >= IntegerCache.low && i <= IntegerCache.high)
 9         return IntegerCache.cache[i + (-IntegerCache.low)];
10     return new Integer(i);
11 }

【3】我们进入工厂角色：Interger 则为我们的具体享元角色。

 1 private static class IntegerCache {
 2     static final int low = -128;
 3     static final int high;
 4     //工厂类中存储对象实例的数组
 5     static final Integer cache[]; 
 6 
 7     static {
 8         ······
 9         high = 127;
10         //定义数组长度 = 127+128+1
11         cache = new Integer[(high - low) + 1];
12         int j = low;
13         for(int k = 0; k < cache.length; k++)
14             //循环创建对象，并放入数组缓存
15             cache[k] = new Integer(j++);
16 
17         // 断言 如果为true 继续执行，false 则抛错
18         assert IntegerCache.high >= 127;
19     }
20 }

七、享元模式的注意事项和细节

1）、对享元模式的理解： “享” 表示共享 “元” 表示对象。
2）、系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元模式。
3）、用唯一标识码判断，如果内存中有则直接返回，一般使用 HashMap、HashTable 或者数组之内进行存储。
4）、享元模式提高了系统的复杂度。需要分离内部状态和外部状态。而外部状态具有固化特性，不应该随着内部状态的改变而改变，这是使用享元模式需要注意的地方。
5）、使用享元模式时，注意划分内部状态和外部状态，并且需要一个工厂类对享元角色进行管理。

posted @ 2020-11-19 14:54 Java程序员进阶阅读(174) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java程序员进阶