前言
这是一篇学习笔记,内容很多是来源于网上的资料,然后按照自己学习情况进行的总结,有些是自身的感受,有些是网上比较好的资料的引用。
如果有人看到我写的笔记有不对的地方欢迎留言指出来,是真的欢迎指出来,因为我可能会错很久,然后才发现。学习技术不能闭门造车,要多交流,多讨论,多思考才能成长的快,学的快。
我的个人博客:海加尔金鹰
什么是享元模式
享元模式的定义与意义
Use sharing to support large numbers of fine-grained objects efficiently.
使用共享对象可有效地支持大量的细粒度的对象。
在面向对象的过程当中,对象的创建是很常见的事情,当对象的的数量过多时,就会带来运行性能下降的问题(消耗了太多的内存)。
享元模式主要用来避免系统创建多个重复对象,达到减少内存消耗的目的。
享元对象能做到共享的关键是区分内部状态和外部状态,内部状态指的是对象创建不会在发生变化的属性,外部状态是指会发生改变的属性。
比较金典的例子说明:围棋游戏当中,存在大量的黑子和白子,每个黑子除了落点位置不同之外,其他的大小颜色都相同。通过享元模式只需要创建一个黑子对象。每次落子的时候获取到的黑子都是同一个对象,大大减少了对象的创建和销毁,提高了性能。
享元模式的结构与角色
享元模式四大角色:
- 抽象享元角色(Flyweight):是所有的具体享元类的基类,为具体享元规范需要实现的公共接口,非享元的外部状态以参数的形式通过方法传入。
- 具体享元(Concrete Flyweight)角色:实现抽象享元角色中所规定的接口。
- 非享元(Unsharable Flyweight)角色:是不可以共享的外部状态,它以参数的形式注入具体享元的相关方法。
- 享元工厂(Flyweight Factory)角色:负责创建和管理享元角色。当客户对象请求一个享元对象时,享元工厂检査系统中是否存在符合要求的享元对象,如果存在则提供给客户;如果不存在的话,则创建一个新的享元对象。1^
享元模式结构实例图:
graph LR
A[Concrete Flyweight] -- 继承 --> B(Flyweight)
D(Unsharable Flyweight) --设置外部状态--> B
C(Flyweight Factory) --创建--> B
享元模式代码实现
享元模式两种分类:
单纯享元模式:不包含非享元角色的,所有的具体享元角色都是可以共享的。
复合享元模式:包含非享元角色,通过组合模式,为不同的单纯享元对象设置相同的外部状态。
单纯享元模式
第一步:创建享元角色类
public abstract class Flyweight {
/**
* location 表示位置属性,外部状态,会发生改变。
*/
public abstract void setLocation(String location);
}
第二步:创建具体享元类,内部状态在创建对象时必须设置好。
public class ConcreteFlyweight extends Flyweight {
//颜色 内部状态,创建后不会改变的属性
private String color = null;
//创建对象的时候必须设置好对象的内部状态,同时设置该构造器为protect 不允许在其他的地方创建该对象,只能通过享元工厂类创建。方便全局的管理。
protected ConcreteFlyweight(String color){
this.color=color;
}
@Override
public void setLocation(String location) {
// doSomething
System.out.println("===color :" +color+"===location :"+location);
}
}
第三步:创建享元工厂类,通过单例模式保证每次获取到的工厂类都是同一个,不然无法实现全局共享。
public class FlyweightFactory {
/**
* 通过工厂模式控制享元对象的生成时,
* 必须保证每次获取到的工厂是同一个工厂,
* 所以采用单例模式来控制工厂模式的创建。
*/
private static FlyweightFactory instance = new FlyweightFactory();
private FlyweightFactory() {
}
public static FlyweightFactory getInstance() {
return instance;
}
//享元池
private Map<String, Flyweight> flyweightMap = new HashMap<>();
/**
* 单纯享元对象获取
* @param color
* @return
*/
public Flyweight getFlyweight(String color) {
// 判断享元池是否包含这个享元对象
if (flyweightMap.containsKey(color)) {
return flyweightMap.get(color);
} else {
//如果不包含就创建一个
Flyweight flyweight = new ConcreteFlyweight(color);
flyweightMap.put(color, flyweight);
return flyweight;
}
}
public void showNumber(){
System.out.println("享元池里面现在有:"+flyweightMap.size()+"个享元对象");
}
}
第四步:创建测试类进行测试及结果
public class FlyweightTest {
public static void main(String[] args) {
FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();
flyweightFactory.getFlyweight("黑色").setLocation("北京");
flyweightFactory.getFlyweight("黑色").setLocation("南京");
flyweightFactory.getFlyweight("黑色").setLocation("西京");
flyweightFactory.getFlyweight("黑色").setLocation("东京");
flyweightFactory.getFlyweight("白色").setLocation("北京");
flyweightFactory.getFlyweight("白色").setLocation("上海");
flyweightFactory.getFlyweight("红色").setLocation("广东");
flyweightFactory.getFlyweight("红色").setLocation("北京");
flyweightFactory.showNumber();
}
}
===color :黑色===location :北京
===color :黑色===location :南京
===color :黑色===location :西京
===color :黑色===location :东京
===color :白色===location :北京
===color :白色===location :上海
===color :红色===location :广东
===color :红色===location :北京
享元池里面现在有:3个享元对象
可以看到只创建了三个对象。节省了对象的创建。
复合享元模式
在单纯享元模式的代码基础上,多了一个非享元角色,主要功能是为多个不同的享元对象设置统一的外部状态。
第一步:添加非享元角色
public class UnsharableFlyweight extends Flyweight {
//用于保存单纯享元对象
private Map<String,Flyweight> flys = new HashMap<>();
/**
* 增加一个新的单纯享元对象到集合中
* @param key
* @param fly 单纯享元对象
*/
public void add(String key , Flyweight fly){
flys.put(key,fly);
}
/**
* 为所有的单纯享元对象统一设置相同的外部状态
* @param location
*/
@Override
public void setLocation(String location) {
for (String s : flys.keySet()) {
flys.get(s).setLocation(location);
}
}
}
第二步:在享元工厂类当中添加创建非享元对象的方法
/**
* 复合享元工厂方法
*/
public Flyweight getUnsharableFlyweight(List<String> colors){
UnsharableFlyweight fly= new UnsharableFlyweight();
for(String color: colors){
fly.add(color,this.getFlyweight(color));
}
return fly;
}
第三步:创建测试类进行测试及结果
public class FlyweightTest {
public static void main(String[] args) {
FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();
List<String> colors = new ArrayList<>();
colors.add("黑色");
Flyweight flyweight1 = flyweightFactory.getUnsharableFlyweight(colors);
Flyweight flyweight2 = flyweightFactory.getUnsharableFlyweight(colors);
System.out.println("非享元角色是否可以共享对象:" + (flyweight1 == flyweight2));
System.out.println("---------------------------------");
String color = "白色";
Flyweight fly1 = flyweightFactory.getFlyweight(color);
Flyweight fly2 = flyweightFactory.getFlyweight(color);
System.out.println("享元角色是否可以共享对象:" + (fly1 == fly2));
flyweightFactory.showNumber();
}
}
非享元角色是否可以共享对象:false
---------------------------------
享元角色是否可以共享对象:true
享元池里面现在有:2个享元对象
享元模式典型应用及总结
典型应用
可以参考JAVA里面的String类,Integer,Long类等等。
享元模式优点
- 可以极大减少内存中对象的数量,节约系统资源,提高系统性能。
- 享元模式的内部状态不会改变,因此可以在不同的环境中被共享。
享元模式缺点
- 系统代码变得复杂多样,需要分离出内部状态和外部状态。
总结:个人感觉享元模式的使用频率应该会越来越少了,毕竟享元模式的主要目的是节约内存,提高性能。但是目前硬件条件的提升,渐渐弥补了内存不足的缺点。并且如果现在一个程序要占用非常高的内存的话,需要认真考量下这个程序到底设计的有没有问题。