设计模式学习笔记 - 设计模式与范式 -结构型:7.享元模式(上):享元模式原理和应用

发布于:2024-03-29 ⋅ 阅读:(10) ⋅ 点赞:(0)

概述

在《设计模式与范式 -结构型:6.组合模式》,讲了组合模式。组合模式并不常用,主要用在数据能表示成树形结构、能通过遍历算法来解决问题的场景中。本章再学习一个不那么常用的模式,享元模式(Flyweight Design Pattern)。这也是学习的最后一个结构型模式。

跟其他所有的设计模式类似,享元模式的原理和实现也非常简单。今天,通过棋牌游戏和文本编辑器两个实际的例子来讲解。此外,还会讲到它跟单例、缓存、对象池的区别和联系。在下一节课中,还会剖析一下享元模式在 Java IntegerString 中的应用。


享元模式原理与实现

所谓 “享元” ,顾名思义就是被共享的单元。享元模式的意图是复用对象,节省内存,前提是享元对象时不可变对象

具体来讲,当一个系统中存在大量重复对象时,如果这些重复对象是不可变对象,就可以利用享元模式将对象设计成享元,在内存中只保留一份实例,供多出代码引用。这样可以减少内存中对象的数量,起到节省内存的作用。实际上,不仅仅相同的对象可以设计成享元,对于相似对象,我们也可以将这些对象中相同的部分抽取出来,设计成享元,让这些大量相似对象引用这些享元。

不可变对象的指的是,一旦通过构造函数初始化完成后,它的状态(对象的成员变量或者属性)就不会被修改了。所以,不可变对象不能暴露任何 set() 等修改内部状态的方法。

之所以要求享元是不可变对象,那是因为它会被多出代码共享使用,避免一处代码对享元进行了修改,影响到其他的代码。

假设我们在开发一个棋牌游戏(比如象棋)。一个游戏厅中有成千上万个 “房间”,每个房间对应一个棋局。棋局要保证每个棋子的数据,比如:棋子类型(将、相、士、炮等)、棋子颜色(红方、黑方)、棋子在棋局中的位置。利用这些数据,就能显示一个完整的棋盘给玩家。具体的代码如下所示。其中, ChessPiece 类表示棋子,ChessBoard 表示一个棋局,里面保存了象棋中 32 个棋子的信息。

public class ChessPiece { // 棋子
    private int id;
    private String text;
    private Color color;
    private int positionX;
    private int positionY;

    public static enum Color {
        RED, BLACK
    }
    // 省略其他属性和getter/setter方法...
}

public class ChessBoard {
    Map<Integer, ChessPiece> chessPieces = new HashMap<>();

    public ChessBoard() {
        this.init();
    }

    private void init() {
        chessPieces.put(1, new ChessPiece(1, "車", ChessPiece.Color.BLACK, 0, 1));
        chessPieces.put(2, new ChessPiece(2, "馬", ChessPiece.Color.BLACK, 0, 1));
        // 省略摆放的其他棋子的代码...
    }

    public void move(int chessPieceId, int toPositionX, int toPositionY) {
        // ...
    }
}

为了记录每个房间当前的棋局情况,我们需要给每个房间都创建一个 ChessBoard 棋局对象。因为游戏大厅中有成千上万的房间(实际上,百万人同时在线的游戏大厅也有很多),那保存这么多棋局对象就会消耗大量的内存。

这个时候,享元模式就派上用场了。像刚刚的实现方式在内存中会有大量的相似对象。这些对象的 idtextcolor 都是想通的,唯独 positionXpositionY 不同。实际上,我们可以将棋子的 idtextcolor 属性拆分出来,设计成独立的类,并且作为享元供多个棋盘复用。这样,棋盘只需要记录棋子的位置信息就可以了。具体的代码实现如下所示。

public class ChessPieceUnit {

    private int id;
    private String text;
    private Color color;

    public static enum Color {
        RED, BLACK
    }

    // 省略其他属性和getter方法...
}

public class ChessPieceUnitFactory {
    private static final Map<Integer, ChessPieceUnit> pieces = new HashMap<>();

    static {
        pieces.put(1, new ChessPieceUnit(1, "車", ChessPieceUnit.Color.BLACK));
        pieces.put(2, new ChessPieceUnit(2, "馬", ChessPieceUnit.Color.BLACK));
        // 省略其他棋子的代码...
    }

    public static ChessPieceUnit getChessPieceUnit(int chessPieceId) {
        return pieces.get(chessPieceId);
    }
}

public class ChessPiece { // 棋子
    private ChessPieceUnit chessPieceUnit;
    private int positionX;
    private int positionY;

    public ChessPiece(ChessPieceUnit chessPieceUnit, int positionX, int positionY) {
        this.chessPieceUnit = chessPieceUnit;
        this.positionX = positionX;
        this.positionY = positionY;
    }

    // 省略getter/setter方法
}

public class ChessBoard {
    Map<Integer, ChessPiece> chessPieces = new HashMap<>();

    public ChessBoard() {
        this.init();
    }

    private void init() {
        chessPieces.put(1, new ChessPiece(
                ChessPieceUnitFactory.getChessPieceUnit(1), 0, 1));
        chessPieces.put(2, new ChessPiece(
                ChessPieceUnitFactory.getChessPieceUnit(2), 0, 1));
        // 省略摆放的其他棋子的代码...
    }

    public void move(int chessPieceId, int toPositionX, int toPositionY) {
        // ...
    }
}

在上面的代码实现中,我们利用工程类来缓存 ChessPieceUnit 信息。通过工厂类获取到的 ChessPieceUnit 就是享元。所有 ChessBoard 对象共享这 32 个 ChessPieceUnit 对象。在使用享元模式之前,记录 1 万个棋局,要创建 32 万个棋子的 ChessPieceUnit 对象。利用响应模式,只需要创建 32 享元对象供所有棋局共享使用,大大节省了内存。

那享元模式的原理讲完了,来总结下它的代码结构。实际上,它的代码结构非常简单,主要是通过工厂模式,在工厂类中,通过一个 Map 来缓存已经创建过的享元对象,来达到复用的目的。

享元模式在文本编辑器中的应用

弄懂了享元模式的原理和实现之后,再来看另一个例子,如何利用享元模式来优化文本编辑器的内存占用?

你可以把这里提到的文本编辑器想象成 Office 的 Word。不过,为了简化需求背景,假设这个文本编辑器只实现文字编辑功能,不包含图片、表格等复杂的编辑功能。对于简化之后的文本编辑器,我们在内存中表示一个文本文件,只需要记录文字和格式两部分信息就可以了,其中格式包括字体大小、颜色等信息。

尽管在实际的文档编写中,一般都是按照文本类型(标题、正文、…)来设置文字的格式。但是,从理论上讲,我们可以给文本文件中的每个文字都设置不同的格式。为了实现如此灵活的设置,并且代码实现又不过于复杂,我们把每个文字都当做一个独立对象来看待,并且在其中包含它的格式信息。具体代码如下所示:

public class Character {
    private char c;
    
    private Font font;
    private int size;
    private int colorRGB;

    public Character(char c, Font font, int size, int colorRGB) {
        this.c = c;
        this.font = font;
        this.size = size;
        this.colorRGB = colorRGB;
    }
}

public class Editor {
    private List<Character> chars = new ArrayList<>();

    public void appendCharacter(char c, Font font, int size, int colorRGB) {
        Character character = new Character(c, font, size, colorRGB);
        chars.add(character);
    }
}

在文本编辑器中,每敲一个字,都会调用 Editor 类中的 appendCharacter() 方法,创建一个新的 Character 对象,保存到 chars 中。如果一个文件中,有上万、几十万的文字,那我们就要在内存中存储这么多的 Character 对象。

实际上,在一个文本文件中,用到的字体格式不会太多,毕竟不大可能有人把每个文字都设置成不同的格式。所以,对于字体格式,我们可以将它设计成享元,让不同的文字共享使用。按照这个设计思路,对上面的代码进行重构。

public class CharacterStyle {
    private Font font;
    private int size;
    private int colorRGB;

    public CharacterStyle(Font font, int size, int colorRGB) {
        this.font = font;
        this.size = size;
        this.colorRGB = colorRGB;
    }

    @Override
    public boolean equals(Object obj) {
        CharacterStyle otherStyle = (CharacterStyle) obj;
        return font.equals(otherStyle.font)
                && size == otherStyle.size
                && colorRGB == otherStyle.colorRGB;
    }
}

public class CharacterStyleFactory {
    private static final List<CharacterStyle> styles = new ArrayList<>();

    public static CharacterStyle getStyle(Font font, int size, int colorRGB) {
        CharacterStyle newStyle = new CharacterStyle(font, size, colorRGB);
        for (CharacterStyle style : styles) {
            if (style.equals(newStyle)) {
                return style;
            }
        }
        styles.add(newStyle);
        return newStyle;
    }
}

public class Character {
    private char c;
    private CharacterStyle style;

    public Character(char c, CharacterStyle style) {
        this.c = c;
        this.style = style;
    }
}

public class Editor {
    private List<Character> chars = new ArrayList<>();

    public void appendCharacter(char c, Font font, int size, int colorRGB) {
        Character character = new Character(c, CharacterStyleFactory.getStyle(font, size, colorRGB));
        chars.add(character);
    }
}

享元 VS 单例、缓存、对象池

上面的讲解中,多次提到 “共享” “缓存” “复用” 这些字眼,那它和单例、缓存、对象池这些概念有什么区别呢?

享元模式和单例的区别

在单例模式中,一个类只能创建一个对象,而在享元模式中,一个类可以创建多个对象,每个对象被多出代码引用共享。实际上,享元模式有点类似与单例的变体:多例。

前面也多次提到,区别两种设计模式,不能光看代码,还要看设计意图,也就是要解决的问题。尽管从代码实现上来看,享元模式和多例有很多相似之处,但从设计意图上来看,它们是完全不同的。应用享元模式是为了对象复用,节省内存,而应用多例是为了限制对象的个数

享元模式和缓存的区别

  • 在享元模式的实现中,我们通过工厂类来缓存已经创建好的对象。这里的 “缓存” 实际上是 “存储” 的意思。
  • 跟我们平时所说的 “数据库缓存” “CPU缓存” “MemCache 缓存” 是两回事。我们平时将的缓存,主要是为了提高访问效率,而非复用。

享元模式和对象池的区别

对象池、连接池、线程池等也是为了复用,它们和享元模式有什么区别呢?

你可能对连接池、线程池比较熟悉,对对象池比较陌生,所以这里简单解释下。像 C++ 这样的编程语言,内存的管理是由程序员负责的。为了避免频繁地创建与释放导致内存碎片,我们可以预先申请一片连续的空间,也就是这里所说的对象池。每次创建对象时,我们从对象池中取出一个空闲对象来使用,对象使用完之后,再放回到对象池中以供后续复用,而非直接释放掉。

虽然对象池、连接池、线程池、享元模式都是为了复用,但是,如果我们在细致地扣一扣 “复用” 这个字眼的话,对象池、连接池、线程池 等池化技术中的 “复用” 和享元模式中的 “复用” 实际上是不同的概念。

  • 池化技术中的 “复用” 可以理解为重复使用,主要目的是节省时间(比如从数据库池中取一个连接,不需要重新创建)。在任意时刻,每一个对象、连接、线程,并不会被多处使用,而是被一个使用者独占,当使用完成之后,放回到池中,再由其他使用者重复利用。
  • 享元模式中的 “复用” 可以理解为共享使用。在整个生命周期中,都是被所有使用者共享的,主要目的是节省空间

总结

1.享元模式的原理

所谓 “享元”,就是被共享的单元。享元模式的意图是复用对象,节省内存,前提是享元对象时不可变对象。具体来讲,当一个系统中存在大量重复对象的时候,就可以利用享元模式,将对象设计成享元,在内存中只保留一份实例,供多处代码引用,这样可以减少内存中对象的数量,以及起到节省内存的目的。

实际上,不仅仅相同的对象可以设计成享元,对于相似的对象,也可以将这些对象中相同的部分(字段),提取出来设计成享元,让这些大量相似对象引入这些享元。

2.享元模式的实现

享元模式的代码实现非常简单,主要是通过工厂模式,在工厂类中,通过一个 Map 或者 List 来缓存已经创建好的对象,已达到复用的目的。

3.享元模式 VS 单例、缓存、对象池

  • 应用单例是为了保证对象全局唯一。
  • 应用享元模式是为了实现对象复用,节省内存。
  • 缓存是为了提高访问效率,而非复用。
  • 池化技术中的 “复用” 理解为 “重复使用”,主要是为了节省实现。
本文含有隐藏内容,请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到