在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式的定义与特点

享元（Flyweight）模式的定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。其主要缺点是：

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

    享元模式的结构与实现

    享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
  • 内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
  • 外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

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

1. 模式的结构

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

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

图 1 是享元模式的结构图，其中：

  • UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；
  • Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
  • ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；
  • FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；
  • 客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

享元模式(Flyweight) - 图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. }
  17. //非享元角色
  18. class UnsharedConcreteFlyweight {
  19.     private String info;
  21.     UnsharedConcreteFlyweight(String info) {
  22.         this.info = info;
  23.     }
  25.     public String getInfo() {
  26.         return info;
  27.     }
  29.     public void setInfo(String info) {
  30.         this.info = info;
  31.     }
  32. }
  34. //抽象享元角色
  35. interface Flyweight {
  36.     public void operation(UnsharedConcreteFlyweight state);
  37. }
  39. //具体享元角色
  40. class ConcreteFlyweight implements Flyweight {
  41.     private String key;
  43.     ConcreteFlyweight(String key) {
  44.         this.key = key;
  45.         System.out.println("具体享元" + key + "被创建！");
  46.     }
  48.     public void operation(UnsharedConcreteFlyweight outState) {
  49.         System.out.print("具体享元" + key + "被调用，");
  50.         System.out.println("非享元信息是:" + outState.getInfo());
  51.     }
  52. }
  54. //享元工厂角色
  55. class FlyweightFactory {
  56.     private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
  58.     public Flyweight getFlyweight(String key) {
  59.         Flyweight flyweight = (Flyweight) flyweights.get(key);
  60.         if (flyweight != null) {
  61.             System.out.println("具体享元" + key + "已经存在，被成功获取！");
  62.         } else {
  63.             flyweight = new ConcreteFlyweight(key);
  64.             flyweights.put(key, flyweight);
  65.         }
  66.         return flyweight;
  67.     }
  68. }

程序运行结果如下：

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

享元模式的应用实例

【例1】享元模式在五子棋游戏中的应用。分析：五子棋同围棋一样，包含多个“黑”或“白”颜色的棋子，所以用享元模式比较好。本实例中:

  • 棋子（ChessPieces）类是抽象享元角色，它包含了一个落子的 DownPieces(Graphics g,Point pt) 方法；
  • 白子（WhitePieces）和黑子（BlackPieces）类是具体享元角色，它实现了落子方法；
  • Point 是非享元角色，它指定了落子的位置；
  • WeiqiFactory 是享元工厂角色，它通过 ArrayList 来管理棋子，并且提供了获取白子或者黑子的 getChessPieces(String type) 方法；
  • 客户类（Chessboard）利用 Graphics 组件在框架窗体中绘制一个棋盘，并实现 mouseClicked(MouseEvent e) 事件处理方法，该方法根据用户的选择从享元工厂中获取白子或者黑子并落在棋盘上。

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

享元模式的应用场景

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多出需要使用的地方，避免大量同一对象的多次创建，降低大量内存空间的消耗。享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。前面分析了享元模式的结构与特点，下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。

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

    享元模式的扩展

    在前面介绍的享元模式中，其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中，有时候会稍加改变，即存在两种特殊的享元模式：单纯享元模式和复合享元模式，下面分别对它们进行简单介绍。(1)单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构图如图 4 所示。享元模式(Flyweight) - 图3
    图4 单纯享元模式的结构图
    (2) 复合享元模式，这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享，其结构图如图 5 所示。享元模式(Flyweight) - 图4
    图5 复合享元模式的结构图