当前咱们国家正在大力倡导构建和谐社会,其中一个很重要的组成部分就是建设资源节约型社会,“浪费可耻,节俭光荣”。在软件系统中,有时候也会存在资源浪费的情况,例如在计算机内存中存储了多个完全相同或者非常相似的对象,如果这些对象的数量太多将导致系统运行代价过高,内存属于计算机的“稀缺资源”,不应该用来“随便浪费”,那么是否存在一种技术可以用于节约内存使用空间,实现对这些相同或者相似对象的共享访问呢?答案是肯定,这种技术就是我们本章将要学习的享元模式。
Sunny软件公司欲开发一个围棋软件,其界面效果如图1-1所示:
图1-1 围棋软件界面效果图
Sunny软件公司开发人员通过对围棋软件进行分析,发现在围棋棋盘中包含大量的黑子和白子,它们的形状、大小都一模一样,只是出现的位置不同而已。如果将每一个棋子都作为一个独立的对象存储在内存中,将导致该围棋软件在运行时所需内存空间较大,如何降低运行代价、提高系统性能是Sunny公司开发人员需要解决的一个问题。为了解决这个问题,Sunny公司开发人员决定使用享元模式来设计该围棋软件的棋子对象,那么享元模式是如何实现节约内存进而提高系统性能的呢?别着急,下面让我们正式进入享元模式的学习。
当一个软件系统在运行时产生的对象数量太多,将导致运行代价过高,带来系统性能下降等问题。例如在一个文本字符串中存在很多重复的字符,如果每一个字符都用一个单独的对象来表示,将会占用较多的内存空间,那么我们如何去避免系统中出现大量相同或相似的对象,同时又不影响客户端程序通过面向对象的方式对这些对象进行操作?享元模式正为解决这一类问题而诞生。享元模式通过共享技术实现相同或相似对象的重用,在逻辑上每一个出现的字符都有一个对象与之对应,然而在物理上它们却共享同一个享元对象,这个对象可以出现在一个字符串的不同地方,相同的字符对象都指向同一个实例,在享元模式中,存储这些共享实例对象的地方称为享元池(Flyweight Pool)。我们可以针对每一个不同的字符创建一个享元对象,将其放在享元池中,需要时再从享元池取出。如图2-1所示:
图2-1 字符享元对象示意图
emsp;享元模式以共享的方式高效地支持大量的细粒度对象的重用,享元对象能做到共享的关键是区分了内部状态(Intrinsic State)和外部状态(Extrinsic State)。下面将对享元的内部状态和外部状态进行简单的介绍:
正因为区分了内部状态和外部状态,我们可以将具有相同内部状态的对象存储在享元池中,享元池中的对象是可以实现共享的,需要的时候就将对象从享元池中取出,实现对象的复用。通过向取出的对象注入不同的外部状态,可以得到一系列相似的对象,而这些对象在内存中实际上只存储一份。
享元模式结构较为复杂,一般结合工厂模式一起使用,在它的结构图中包含了一个享元工厂类,其结构图如图2.2-1所示:
图2.2-1 享元模式结构图
在享元模式结构图中包含如下几个角色:
在享元模式中引入了享元工厂类,享元工厂类的作用在于提供一个用于存储享元对象的享元池,当用户需要对象时,首先从享元池中获取,如果享元池中不存在,则创建一个新的享元对象返回给用户,并在享元池中保存该新增对象。典型的享元工厂类的代码如下:
class FlyweightFactory {
//定义一个HashMap用于存储享元对象,实现享元池
private HashMap flyweights = new HashMap<>();
public Flyweight getFlyweight(String key){
//如果对象存在,则直接从享元池获取
if(flyweights.containsKey(key)){
return(Flyweight)flyweights.get(key);
}
//如果对象不存在,先创建一个新的对象添加到享元池中,然后返回
else {
Flyweight fw = newConcreteFlyweight();
flyweights.put(key,fw);
return fw;
}
}
}
享元类的设计是享元模式的要点之一,在享元类中要将内部状态和外部状态分开处理,通常将内部状态作为享元类的成员变量,而外部状态通过注入的方式添加到享元类中。典型的享元类代码如下所示:
class Flyweight {
//内部状态intrinsicState作为成员变量,同一个享元对象其内部状态是一致的
private String intrinsicState;
public Flyweight(String intrinsicState) {
this.intrinsicState=intrinsicState;
}
//外部状态extrinsicState在使用时由外部设置,不保存在享元对象中,即使是同一个对象,在每一次调用时也可以传入不同的外部状态
public void operation(String extrinsicState) {
......
}
}
为了节约存储空间,提高系统性能,Sunny公司开发人员使用享元模式来设计围棋软件中的棋子,其基本结构如图3-1所示
图3-1围棋棋子结构图
在图3-1IoChessman充当抽象享元类,BlackIgoChessman和WhiteIgoChessman充当具体享元类,IgoChessmanFactory充当享元工厂类。完整代码如下所示:
IgoChessman类代码3-1:围棋棋子类-抽象享元类
package flyweight;
//围棋棋子类:抽象享元类
public abstract class IgoChessman {
public abstract String getColor();
public void display() {
System.out.println("棋子颜色:" + this.getColor());
}
}
BlackIgoChessman类代码3-2:黑色棋子类-具体享元类
package flyweight;
//黑色棋子类:具体享元类
public class BlackIgoChessman extends IgoChessman{
@Override
public String getColor() {
return "黑色";
}
}
WhiteIgoChessman类代码3-3:白色棋子类-具体享元类
package flyweight;
//白色棋子类:具体享元类
public class WhiteIgoChessman extends IgoChessman{
@Override
public String getColor() {
return "白色";
}
}
IgoChessmanFactory类代码3-4:围棋棋子工厂类-享元工厂类,当了模式设计
package flyweight;
import java.util.HashMap;
//围棋棋子工厂类:享元工厂类,使用单例模式进行设计
public class IgoChessmanFactory {
private static IgoChessmanFactory instance = new IgoChessmanFactory();
private static HashMap hm;
private IgoChessmanFactory() {
hm = new HashMap<>();
hm.put("b", new BlackIgoChessman());
hm.put("w", new WhiteIgoChessman());
}
public static IgoChessmanFactory getInstance() {
return instance;
}
public IgoChessman getIgoChessman(String key) {
return hm.get(key);
}
}
Client类代码3-5:客户端测试类
package flyweight;
public class Client {
public static void main(String[] args) {
IgoChessman b1, b2, b3, w1, w2;
IgoChessmanFactory factory;
factory = IgoChessmanFactory.getInstance();
b1 = factory.getIgoChessman("b");
b2 = factory.getIgoChessman("b");
b3 = factory.getIgoChessman("b");
System.out.println("判断两颗黑子是否相同:" + (b1 == b2));
w1 = factory.getIgoChessman("w");
w2 = factory.getIgoChessman("w");
System.out.println("判断两颗白子是否相同:" + (w1==w2));
b1.display();
b2.display();
b3.display();
w1.display();
w2.display();
}
}
测试结果:
判断两颗黑子是否相同:true
判断两颗白子是否相同:true
棋子颜色:黑色
棋子颜色:黑色
棋子颜色:黑色
棋子颜色:白色
棋子颜色:白色
从输出结果可以看出,虽然我们获取了三个黑子对象和两个白子对象,但是它们的内存地址相同,也就是说,它们实际上是同一个对象。在实现享元工厂类时我们使用了单例模式和简单工厂模式,确保了享元工厂对象的唯一性,并提供工厂方法来向客户端返回享元对象。
Sunny软件公司开发人员通过对围棋棋子进行进一步分析,发现虽然黑色棋子和白色棋子可以共享,但是它们将显示在棋盘的不同位置,如何让相同的黑子或者白子能够多次重复显示且位于一个棋盘的不同地方?解决方法就是将棋子的位置定义为棋子的一个外部状态,在需要时再进行设置。因此,我们在图3-1中增加了一个新的类Coordinates(坐标类),用于存储每一个棋子的位置,修改之后的结构图如图4-1所示:
图4-1 引入外部状态之后的围棋棋子结构图
在图4-1中,除了增加一个坐标类Coordinates以外,抽象享元类IgoChessman中的display()方法也将对应增加一个Coordinates类型的参数,用于在显示棋子时指定其坐标,Coordinates类和修改之后的IgoChessman类的代码如下所示:
package flyweight;
//坐标类:外部状态类
public class Coordinate {
private int x;
private int y;
public Coordinate() {}
public Coordinate(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "(" + this.x + ", " + this.y + ")";
}
}
//围棋棋子类:抽象享元类
package flyweight;
//围棋棋子类:抽象享元类
public abstract class IgoChessman {
public abstract String getColor();
public void display(Coordinate coord) {
System.out.println("棋子颜色:" + this.getColor() + "," + coord);
}
}
客户端测试代码修改如下:
package flyweight;
public class Client {
public static void main(String[] args) {
IgoChessman b1, b2, b3, w1, w2;
IgoChessmanFactory factory;
factory = IgoChessmanFactory.getInstance();
b1 = factory.getIgoChessman("b");
b2 = factory.getIgoChessman("b");
b3 = factory.getIgoChessman("b");
System.out.println("判断两颗黑子是否相同:" + (b1 == b2));
w1 = factory.getIgoChessman("w");
w2 = factory.getIgoChessman("w");
System.out.println("判断两颗白子是否相同:" + (w1==w2));
b1.display(new Coordinate(1, 2));
b2.display(new Coordinate(3, 4));
b3.display(new Coordinate(1, 3));
w1.display(new Coordinate(2, 5));
w2.display(new Coordinate(2, 4));
}
}
测试结果:
判断两颗黑子是否相同:true
判断两颗白子是否相同:true
棋子颜色:黑色,(1, 2)
棋子颜色:黑色,(3, 4)
棋子颜色:黑色,(1, 3)
棋子颜色:白色,(2, 5)
棋子颜色:白色,(2, 4)
从输出结果可以看到,在每次调用display()方法时,都设置了不同的外部状态——坐标值,因此相同的棋子对象虽然具有相同的颜色,但是它们的坐标值不同,将显示在棋盘的不同位置。
标准的享元模式结构图中既包含可以共享的具体享元类,也包含不可以共享的非共享具体享元类。但是在实际使用过程中,我们有时候会用到两种特殊的享元模式:单纯享元模式和复合享元模式,下面将对这两种特殊的享元模式进行简单的介绍:
在单纯享元模式中,所有的具体享元类都是可以共享的,不存在非共享具体享元类。单纯享元模式的结构如图5.1-1所示:
图5.1-1 单纯享元模式结构图
将一些单纯享元对象使用组合模式加以组合,还可以形成复合享元对象,这样的复合享元对象本身不能共享,但是它们可以分解成单纯享元对象,而后者则可以共享。复合享元模式的结构如图5.2-1所示:
图5.2-1 符合享元模式结构图
通过复合享元模式,可以确保复合享元类CompositeConcreteFlyweight中所包含的每个单纯享元类ConcreteFlyweight都具有相同的外部状态,而这些单纯享元的内部状态往往可以不同。如果希望为多个内部状态不同的享元对象设置相同的外部状态,可以考虑使用复合享元模式。
享元模式通常需要和其他模式一起联用,几种常见的联用方式如下:
JDK类库中的String类使用了享元模式,我们通过如下代码来加以说明:
class Demo {
public static void main(String args[]) {
String str1 = "abcd";
String str2 = "abcd";
String str3 = "ab" + "cd";
String str4 = "ab";
str4 += "cd";
System.out.println(str1 == str2);
System.out.println(str1 == str3);
System.out.println(str1 == str4);
str2 += "e";
System.out.println(str1 == str2);
}
}
在Java语言中,如果每次执行类似String str1=“abcd"的操作时都创建一个新的字符串对象将导致内存开销很大,因此如果第一次创建了内容为"abcd"的字符串对象str1,下一次再创建内容相同的字符串对象str2时会将它的引用指向"abcd”,不会重新分配内存空间,从而实现了"abcd"在内存中的共享。上述代码输出结果如下:
true
true
false
false
可以看出,前两个输出语句均为true,说明str1、str2、str3在内存中引用了相同的对象;如果有一个字符串str4,其初值为"ab",再对它进行操作str4 += “cd”,此时虽然str4的内容与str1相同,但是由于str4的初始值不同,在创建str4时重新分配了内存,所以第三个输出语句结果为false;最后一个输出语句结果也为false,说明当对str2进行修改时将创建一个新的对象,修改工作在新对象上完成,而原来引用的对象并没有发生任何改变,str1仍然引用原有对象,而str2引用新对象,str1与str2引用了两个完全不同的对象。
关于Java String类这种在修改享元对象时,先将原有对象复制一份,然后在新对象上再实施修改操作的机制称为“Copy On Write”,大家可以自行查询相关资料来进一步了解和学习“Copy On Write”机制,在此不作详细说明。
当系统中存在大量相同或者相似的对象时,享元模式是一种较好的解决方案,它通过共享技术实现相同或相似的细粒度对象的复用,从而节约了内存空间,提高了系统性能。相比其他结构型设计模式,享元模式的使用频率并不算太高,但是作为一种以“节约内存,提高性能”为出发点的设计模式,它在软件开发中还是得到了一定程度的应用。
在以下情况下可以考虑使用享元模式:
参考文献:Java设计模式(刘伟).pdf。持续更新,欢迎交流,本人QQ:806797785
前端项目源代码地址:https://gitee.com/gaogzhen/vue-leyou
后端JAVA源代码地址:https://gitee.com/gaogzhen/JAVA