设计模式-享元模式

笔记

参考：http://c.biancheng.net/view/1371.html

什么是享元模式

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

优点：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点：

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

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

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

模式的结构

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

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

1.png

  • UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；
  • Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
  • ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；
  • FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；
  • 客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class UnsharedConcreteFlyweight {
    private String info;

    public UnsharedConcreteFlyweight(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}
1
2
3
public interface Flyweight {
    void operation(UnsharedConcreteFlyweight state);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ConcreteFlyweight implements Flyweight {

    private String key;

    public ConcreteFlyweight(String key) {
        this.key = key;
        System.out.println("享元对象：" + key + "被创建！");
    }

    @Override
    public void operation(UnsharedConcreteFlyweight state) {
        System.out.println("享元对象" + key + "被调用!!!");
        System.out.println("非享元信息：" + state.getInfo());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class FlyweightFactory {
    private static HashMap<String,Flyweight> flyweightMap = new HashMap<>();

    public static Flyweight getFlyweight(String key){
        Flyweight flyweight = flyweightMap.get(key);
        if (null!=flyweight){
            System.out.println("享元对象："+key+"已存在，成功获取！");
        }else {
            flyweight = new ConcreteFlyweight(key);
            flyweightMap.put(key,flyweight);
        }
        return flyweight;
    }
}
1
2
3
4
5
6
7
8
9
public class Main {
    public static void main(String[] args) {
        Flyweight a001 = FlyweightFactory.getFlyweight("a001");
        Flyweight a002 = FlyweightFactory.getFlyweight("a002");
        Flyweight a0022 = FlyweightFactory.getFlyweight("a002");
        a001.operation(new UnsharedConcreteFlyweight("a001"));
        a002.operation(new UnsharedConcreteFlyweight("a002"));
    }
}

运行结果：

1
2
3
4
5
6
7
享元对象：a001被创建！
享元对象：a002被创建！
享元对象：a002已存在，成功获取！
享元对象a001被调用!!!
非享元信息：a001
享元对象a002被调用!!!
非享元信息：a002

应用实例

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

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

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

2.png

1
2
3
4
5
6
7
8
public interface ChessPieces {
    /**
     * 下子
     * @param g
     * @param pt
     */
    void DownPieces(Graphics g,Point pt);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class WhitePieces implements ChessPieces{

    public WhitePieces() {
        System.out.println("白棋被创建！");
    }

    @Override
    public void DownPieces(Graphics g, Point pt) {
        System.out.println("白棋被调用！！");
        g.setColor(Color.white);
        g.fillOval(pt.x, pt.y, 30,30);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class BlackPieces implements ChessPieces{

    public BlackPieces() {
        System.out.println("黑棋被创建！");
    }

    @Override
    public void DownPieces(Graphics g, Point pt) {
        System.out.println("黑棋被调用！！");
        g.setColor(Color.black);
        g.fillOval(pt.x, pt.y, 30,30);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 享元工厂
public class WeiqiFactory {
    private HashMap<String,ChessPieces> qz;

    public WeiqiFactory(){
        qz = new HashMap<>();
        qz.put("w",new WhitePieces());
        qz.put("b",new BlackPieces());
    }

    public ChessPieces getChessPieces(String type){
        return qz.get(type);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// 棋盘
public class Chessboard extends MouseAdapter {
    WeiqiFactory wf;
    JFrame f;
    Graphics g;
    JRadioButton wz;
    JRadioButton bz;
    private final int x = 50;
    private final int y = 50;
    private final int w = 40;    //小方格宽度和高度
    private final int rw = 400;    //棋盘宽度和高度

    Chessboard() {
        wf = new WeiqiFactory();
        f = new JFrame("享元模式在五子棋游戏中的应用");
        f.setBounds(100, 100, 500, 550);
        f.setVisible(true);
        f.setResizable(false);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel SouthJP = new JPanel();
        f.add("South", SouthJP);
        wz = new JRadioButton("白子");
        bz = new JRadioButton("黑子", true);
        ButtonGroup group = new ButtonGroup();
        group.add(wz);
        group.add(bz);
        SouthJP.add(wz);
        SouthJP.add(bz);
        JPanel CenterJP = new JPanel();
        CenterJP.setLayout(null);
        CenterJP.setSize(500, 500);
        CenterJP.addMouseListener(this);
        f.add("Center", CenterJP);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        g = CenterJP.getGraphics();
        g.setColor(Color.BLUE);
        g.drawRect(x, y, rw, rw);
        for (int i = 1; i < 10; i++) {
            //绘制第i条竖直线
            g.drawLine(x + (i * w), y, x + (i * w), y + rw);
            //绘制第i条水平线
            g.drawLine(x, y + (i * w), x + rw, y + (i * w));
        }
    }

    public void mouseClicked(MouseEvent e) {
        Point pt = new Point(e.getX() - 15, e.getY() - 15);
        if (wz.isSelected()) {
            ChessPieces c1 = wf.getChessPieces("w");
            c1.DownPieces(g, pt);
        } else if (bz.isSelected()) {
            ChessPieces c2 = wf.getChessPieces("b");
            c2.DownPieces(g, pt);
        }
    }
}
1
2
3
4
5
public class WzqGame {
    public static void main(String[] args) {
        new Chessboard();
    }
}

运行结果：

3.png

1
2
3
4
5
6
白棋被创建！
黑棋被创建！
黑棋被调用！！
白棋被调用！！
黑棋被调用！！
白棋被调用！！

应用场景

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

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

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

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

扩展

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

(1) 单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类。

4.png

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

5.png