1.定义
享元模式属于结构型模式中的一种,其目的是为了减少大量相似对象的创建,降低资源消耗,提高系统的性能。从本质上看,享元模式是利用共享的方式使得大量的细粒度对象能够被复用,大幅减少需要创建的对象数量,以达到高效利用资源。
最熟悉的实现实例就是数据库连接池、线程池、Integer缓存,提到这几个,就能对享元有一个大概的认识方向,具体做法就是提前创建他们, 并缓存到指定的容器,当需要对象时,从该容器获取,使用结束后,将对象返还给容器,而容器也可以根据实际的情况,添加/删除对象,或者进行扩缩容。
关键点:
在这样的对象共享机制下,根据对象的状态分为两部分:
- 内部状态:所有对象抽象层面共享的部分,这部分在所有对象内部都是常量,不会随着外部环境改变而改变
- 外部状态:外部状态会因为外部环境的改变而发生改变
怎么理解?其实就是将对象可变部分和不可变的部分分离,不可变的部分维护在对象内部,可变部分通过参数的方式对外提供出去,获取对象的时候,由外部来设定该参数,从而获取到真正需要的对象
比如以围棋为例,棋盘上那么多棋子,如果每个棋子都用一个单独的对象表示,会产生大量的对象,而且它们都是相似的,实际上对象只有白棋和黑棋两种,他们都是棋子,形状相同,质量相同(内部状态)…,不同的是颜色,和落棋位置(外部状态)
总结:享元类包含原始对象中部分能在多个对象中共享的状态,同一享元对象可在许多不同场景中使用,享元中存储的状态被称之为内部状态,传递给享元方法的状态被称作外部状态
通过分离两种状态,对内在状态重用,使得所需的对象数量大大减少,毕竟与外在状态相比,内在状态的变体要少很多
至此,可以看出享元模式最重要的其实就是不变部分和可变部分的分离。
角色介绍:
- 抽象享元角色(FlyWeight):是所有具体享元类的抽象类,提供所有具体享元类需要实现的公共接口,非享元的外部状态以参数的形式通过方法传入
- 具体享元角色(Concrete Flyweight):实现抽象享元角色中规定的接口
- 非享元角色(Unsharable Flyweight):是不可以共享的外部状态,它以参数的形式注入具体的享元的方法中
- 享元工厂角色(Flyweight Factory):负责创建和管理享元角色,当客户端请求一个享元对象时,享元工厂负责检查是否存在符合要求的享元对象,如果存在,则返回,如果不存在,创建并返回,这是一个解耦的过程。
图片来源:知乎
2.示例
以棋子为例,对享元模式进行一个简单的实现,具体做法
- 通过对享元对象分析,将享元对象拆分出两个部分,内在部分和外在部分,这也是享元设计模式中最关键的一步
- 内在部分的成员属于所有享元对象共有属性,一般是只读状态,外在部分成员通过方法参数的形式暴露出去,允许外部修改
- 最后就是定义一个工厂类,来负责管理和创建享元对象,具体实现方式根据实际情况灵活设计
首先先创建享元的抽象角色,也就是棋子的抽象层
/**
* @description: 抽象享元角色
* @version: 1.0
*/
public interface ChessPieces {
void downPieces();
}
对棋子进行实现,具体实现可以根据实际的情况有多个,这里只使用一个说明原理
如果将所有对象的共享状态简化成一个享元对象,有点类似单例,不同的是单例只有一个实体,而享元可以有多个,每个实体的内在状态也可以不同
/**
* @description: 具体享元角色
* @version: 1.0
*/
public class ConcretePieces implements ChessPieces{
//外部状态
private int x;
private int y;
private String color;
//内部状态
private String shape;
//其他内部状态
//.....
public ConcretePieces(){
this("circle");
}
public ConcretePieces(String shape){
this.shape = shape;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public void setColor(String color) {
this.color = color;
}
@Override
public void downPieces() {
System.out.println(shape + ":" +color + "=>(" + x + "," + y + ")" );
}
}
定义一个工厂类,用于管理所有的享元对象
/**
* @description: 管理工厂
* @version: 1.0
*/
public class PiecesFactory {
private static final Map<String,ChessPieces> cache = new HashMap<>();
public static ChessPieces getPieces(String color,int x,int y){
ConcretePieces chessPieces = (ConcretePieces) cache.get(color + y + y);
//如果不存在,则创建 并缓存
if (chessPieces == null){
chessPieces = new ConcretePieces();
chessPieces.setColor(color);
chessPieces.setX(x);
chessPieces.setY(y);
cache.put(color+x+y,chessPieces);
}
return chessPieces;
}
}
测试:
/**
* @description: test
* @version: 1.0
*/
public class Test {
private static final String PIECES_COLOR[] = {"white","black"};
public static void main(String[] args) {
for (int i = 0 ; i < 10; i++){
String color = PIECES_COLOR[i % 2];
int x = (int)(Math.random()*100);
int y = (int)(Math.random()*100);
ChessPieces pieces = PiecesFactory.getPieces(color, x, y);
pieces.downPieces();
}
}
}
input:
circle:white=>(51,25)
circle:black=>(52,1)
circle:white=>(52,6)
circle:black=>(65,40)
circle:white=>(87,9)
circle:black=>(64,0)
circle:white=>(5,24)
circle:black=>(34,30)
circle:white=>(60,72)
circle:black=>(41,31)
以上是对享元模式的一个简单实现,当然,实际应用中远远复杂许多,设计模式只是提供了一个思想的基础框架,具体实现还需要根据实际的情况来衡量。
如果系统中需要经常创建许多相似的对象,并且内存很珍贵,在没有其他更好的解决方案情况下,使用享元模式是其中一个可以考虑的方向。
3.总结
享元模式的优点在于它可以极大的减少内存中对象的数量,使得相同或相似的对象在内存中的数量是相对固定的,并且由于其划分内外状态的思想,享元模式有很好的独立性,外部状态的改变不会影响到内部状态,可以使享元对象在不同环境中被共享使用。
享元模式的缺点也是显而易见的,其一是将对象状态分离增加了一定的复杂性,其二是将部分成员外部化,读取外部状态使得运行时间增加。