其他分享
首页 > 其他分享> > 24、享元模式(详解版)

24、享元模式(详解版)

作者:互联网

在面向对象程序设计过程中,有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源,它是系统性能提高的一个瓶颈。

例如,围棋和五子棋中的黑白棋子,图像中的坐标点或颜色,局域网中的路由器、交换机和集线器,教室里的桌子和凳子等。这些对象有很多相似的地方,如果能把它们相同的部分提取出来共享,则能节省大量的系统资源,这就是享元模式的产生背景。

享元模式的定义与特点

享元(Flyweight)模式的定义:运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销,从而提高系统资源的利用率。

享元模式的主要优点是:相同对象只要保存一份,这降低了系统中对象的数量,从而降低了系统中细粒度对象给内存带来的压力。

其主要缺点是:

  1. 为了使对象可以共享,需要将一些不能共享的状态外部化,这将增加程序的复杂性。
  2. 读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式的定义提出了两个要求,细粒度和共享对象。因为要求细粒度,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。


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

享元模式的本质是缓存共享对象,降低内存消耗。

1. 模式的结构

享元模式的主要角色有如下。

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


图 1 是享元模式的结构图,其中:

 

享元模式的结构图
图1 享元模式的结构图

2. 模式的实现

享元模式的实现代码如下:

  1. public class FlyweightPattern {
  2. public static void main(String[] args) {
  3. FlyweightFactory factory = new FlyweightFactory();
  4. Flyweight f01 = factory.getFlyweight("a");
  5. Flyweight f02 = factory.getFlyweight("a");
  6. Flyweight f03 = factory.getFlyweight("a");
  7. Flyweight f11 = factory.getFlyweight("b");
  8. Flyweight f12 = factory.getFlyweight("b");
  9. f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
  10. f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
  11. f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
  12. f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
  13. f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
  14. }
  15. }
  16. //非享元角色
  17. class UnsharedConcreteFlyweight {
  18. private String info;
  19. UnsharedConcreteFlyweight(String info) {
  20. this.info = info;
  21. }
  22. public String getInfo() {
  23. return info;
  24. }
  25. public void setInfo(String info) {
  26. this.info = info;
  27. }
  28. }
  29. //抽象享元角色
  30. interface Flyweight {
  31. public void operation(UnsharedConcreteFlyweight state);
  32. }
  33. //具体享元角色
  34. class ConcreteFlyweight implements Flyweight {
  35. private String key;
  36. ConcreteFlyweight(String key) {
  37. this.key = key;
  38. System.out.println("具体享元" + key + "被创建!");
  39. }
  40. public void operation(UnsharedConcreteFlyweight outState) {
  41. System.out.print("具体享元" + key + "被调用,");
  42. System.out.println("非享元信息是:" + outState.getInfo());
  43. }
  44. }
  45. //享元工厂角色
  46. class FlyweightFactory {
  47. private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
  48. public Flyweight getFlyweight(String key) {
  49. Flyweight flyweight = (Flyweight) flyweights.get(key);
  50. if (flyweight != null) {
  51. System.out.println("具体享元" + key + "已经存在,被成功获取!");
  52. } else {
  53. flyweight = new ConcreteFlyweight(key);
  54. flyweights.put(key, flyweight);
  55. }
  56. return flyweight;
  57. }
  58. }

程序运行结果如下:

具体享元a被创建!
具体享元a已经存在,被成功获取!
具体享元a已经存在,被成功获取!
具体享元b被创建!
具体享元b已经存在,被成功获取!
具体享元a被调用,非享元信息是:第1次调用a。
具体享元a被调用,非享元信息是:第2次调用a。
具体享元a被调用,非享元信息是:第3次调用a。
具体享元b被调用,非享元信息是:第1次调用b。
具体享元b被调用,非享元信息是:第2次调用b。

享元模式的应用实例

【例1】享元模式在五子棋游戏中的应用。

分析:五子棋同围棋一样,包含多个“黑”或“白”颜色的棋子,所以用享元模式比较好。

本实例中:


图 2 所示是其结构图。

五子棋游戏的结构图
图2 五子棋游戏的结构图


程序代码如下:

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.MouseAdapter;
  4. import java.awt.event.MouseEvent;
  5. import java.util.ArrayList;
  6. public class WzqGame {
  7. public static void main(String[] args) {
  8. new Chessboard();
  9. }
  10. }
  11. //棋盘
  12. class Chessboard extends MouseAdapter {
  13. WeiqiFactory wf;
  14. JFrame f;
  15. Graphics g;
  16. JRadioButton wz;
  17. JRadioButton bz;
  18. private final int x = 50;
  19. private final int y = 50;
  20. private final int w = 40; //小方格宽度和高度
  21. private final int rw = 400; //棋盘宽度和高度
  22. Chessboard() {
  23. wf = new WeiqiFactory();
  24. f = new JFrame("享元模式在五子棋游戏中的应用");
  25. f.setBounds(100, 100, 500, 550);
  26. f.setVisible(true);
  27. f.setResizable(false);
  28. f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  29. JPanel SouthJP = new JPanel();
  30. f.add("South", SouthJP);
  31. wz = new JRadioButton("白子");
  32. bz = new JRadioButton("黑子", true);
  33. ButtonGroup group = new ButtonGroup();
  34. group.add(wz);
  35. group.add(bz);
  36. SouthJP.add(wz);
  37. SouthJP.add(bz);
  38. JPanel CenterJP = new JPanel();
  39. CenterJP.setLayout(null);
  40. CenterJP.setSize(500, 500);
  41. CenterJP.addMouseListener(this);
  42. f.add("Center", CenterJP);
  43. try {
  44. Thread.sleep(500);
  45. } catch (InterruptedException e) {
  46. e.printStackTrace();
  47. }
  48. g = CenterJP.getGraphics();
  49. g.setColor(Color.BLUE);
  50. g.drawRect(x, y, rw, rw);
  51. for (int i = 1; i < 10; i++) {
  52. //绘制第i条竖直线
  53. g.drawLine(x + (i * w), y, x + (i * w), y + rw);
  54. //绘制第i条水平线
  55. g.drawLine(x, y + (i * w), x + rw, y + (i * w));
  56. }
  57. }
  58. public void mouseClicked(MouseEvent e) {
  59. Point pt = new Point(e.getX() - 15, e.getY() - 15);
  60. if (wz.isSelected()) {
  61. ChessPieces c1 = wf.getChessPieces("w");
  62. c1.DownPieces(g, pt);
  63. } else if (bz.isSelected()) {
  64. ChessPieces c2 = wf.getChessPieces("b");
  65. c2.DownPieces(g, pt);
  66. }
  67. }
  68. }
  69. //抽象享元角色:棋子
  70. interface ChessPieces {
  71. public void DownPieces(Graphics g, Point pt); //下子
  72. }
  73. //具体享元角色:白子
  74. class WhitePieces implements ChessPieces {
  75. public void DownPieces(Graphics g, Point pt) {
  76. g.setColor(Color.WHITE);
  77. g.fillOval(pt.x, pt.y, 30, 30);
  78. }
  79. }
  80. //具体享元角色:黑子
  81. class BlackPieces implements ChessPieces {
  82. public void DownPieces(Graphics g, Point pt) {
  83. g.setColor(Color.BLACK);
  84. g.fillOval(pt.x, pt.y, 30, 30);
  85. }
  86. }
  87. //享元工厂角色
  88. class WeiqiFactory {
  89. private ArrayList<ChessPieces> qz;
  90. public WeiqiFactory() {
  91. qz = new ArrayList<ChessPieces>();
  92. ChessPieces w = new WhitePieces();
  93. qz.add(w);
  94. ChessPieces b = new BlackPieces();
  95. qz.add(b);
  96. }
  97. public ChessPieces getChessPieces(String type) {
  98. if (type.equalsIgnoreCase("w")) {
  99. return (ChessPieces) qz.get(0);
  100. } else if (type.equalsIgnoreCase("b")) {
  101. return (ChessPieces) qz.get(1);
  102. } else {
  103. return null;
  104. }
  105. }
  106. }

程序运行结果如图 3 所示。

五子棋游戏的运行结果
图3 五子棋游戏的运行结果

享元模式的应用场景

当系统中多处需要同一组信息时,可以把这些信息封装到一个对象中,然后对该对象进行缓存,这样,一个对象就可以提供给多出需要使用的地方,避免大量同一对象的多次创建,降低大量内存空间的消耗。

享元模式其实是工厂方法模式的一个改进机制,享元模式同样要求创建一个或一组对象,并且就是通过工厂方法模式生成对象的,只不过享元模式为工厂方法模式增加了缓存这一功能。

前面分析了享元模式的结构与特点,下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的,所以以下几种情形适合采用享元模式。

  1. 系统中存在大量相同或相似的对象,这些对象耗费大量的内存资源。
  2. 大部分的对象可以按照内部状态进行分组,且可将不同部分外部化,这样每一个组只需保存一个内部状态。
  3. 由于享元模式需要额外维护一个保存享元的数据结构,所以应当在有足够多的享元实例时才值得使用享元模式。

享元模式的扩展

在前面介绍的享元模式中,其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中,有时候会稍加改变,即存在两种特殊的享元模式:单纯享元模式和复合享元模式,下面分别对它们进行简单介绍。

(1) 单纯享元模式,这种享元模式中的所有的具体享元类都是可以共享的,不存在非共享的具体享元类,其结构图如图 4 所示。

单纯享元模式的结构图
图4 单纯享元模式的结构图


(2) 复合享元模式,这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的,它们就是复合享元对象。虽然复合享元对象本身不能共享,但它们可以分解成单纯享元对象再被共享,其结构图如图 5 所示。

复合享元模式的结构图
图5 复合享元模式的结构图

标签:24,享元,对象,模式,详解,Flyweight,new,public
来源: https://www.cnblogs.com/phpcqy/p/14279871.html