目录
一、享元模式介绍
1.1 享元模式定义
1.2 享元模式原理
1.2.1 享元模式类图
1.2.2 模式角色说明
1.2.3 示例代码
二、享元模式的应用
2.1 需求说明
2.2 需求实现
2.2.1 类图
2.2.2 具体实现
2.2.2.1 抽象享元类
2.2.2.2 共享享元类-白色棋子
2.2.2.3 共享享元类-黑色棋子
2.2.2.4 享元工厂类
2.2.2.5 测试类
三、享元模式总结
3.1 享元模式的优点
3.2 享元模式的缺点
3.3 享元模式的适用场景
一、享元模式介绍
1.1 享元模式定义
享元模式 (flyweight pattern) 的原始定义是：摒弃了在每个对象中保存所有数据的方式，通过共享多个对象所共有的相同状态，从而让我们能在有限的内存容量中载入更多对象。从这个定义中你可以发现，享元模式要解决的核心问题就是节约内存空间，使用的办法是找出相似对象之间的共有特征，然后复用这些特征。所谓“享元”，顾名思义就是被共享的单元。
比如: 一个文本字符串中存在很多重复的字符，如果每一个字符都用一个单独的对象来表示，将会占用较多的内存空间，我们可以使用享元模式解决这一类问题。
享元模式通过共享技术实现相同或者相似对象的重用，在逻辑上每一个出现的字符都有一个对象与之对应，然而在物理上他们却是共享同一个享元对象。
1.2 享元模式原理
1.2.1 享元模式类图
1.2.2 模式角色说明
享元模式的主要有以下角色：
- 抽象享元角色（Flyweight）：
通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。享元（Flyweight）模式中存在以下两种状态：
- 内部状态，即不会随着环境的改变而改变的可共享部分。
- 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。
- 可共享的具体享元（Concrete Flyweight）角色 ：
它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
- 非共享的具体享元（Unshared Flyweight)角色 ：
并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
- 享元工厂（Flyweight Factory）角色 ：
负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。
1.2.3 示例代码
package main.java.cn.test.flyweight.V1;/*** @author ningzhaosheng* @date 2024/1/14 17:20:06* @description 抽象享元类*/
public abstract class Flyweight {public abstract void operation(String extrinsicState);
}package main.java.cn.test.flyweight.V1;/*** @author ningzhaosheng* @date 2024/1/14 17:20:46* @description 可共享-具体享元类*/
public class ConcreteFlyweight extends Flyweight {//内部状态 intrinsicState作为成员变量,同一个享元对象的内部状态是一致的private String intrinsicState;public ConcreteFlyweight(String intrinsicState) {this.intrinsicState = intrinsicState;}/*** 外部状态在使用时由外部设置,不保存在享元对象中,即使是同一个对象** @param extrinsicState 外部状态,每次调用可以传入不同的外部状态*/@Overridepublic void operation(String extrinsicState) {//实现业务方法System.out.println("=== 享元对象内部状态" + intrinsicState + ",外部状态:" + extrinsicState);}}package main.java.cn.test.flyweight.V1;/*** @author ningzhaosheng* @date 2024/1/14 17:23:16* @description 非共享具体享元类*/
public class UnsharedConcreteFlyweight extends Flyweight {private String intrinsicState;public UnsharedConcreteFlyweight(String intrinsicState) {this.intrinsicState = intrinsicState;}@Overridepublic void operation(String extrinsicState) {System.out.println("=== 使用不共享对象,内部状态: " + intrinsicState + ",外部状态: " + extrinsicState);}
}package main.java.cn.test.flyweight.V1;import java.util.HashMap;
import java.util.Map;/*** @author ningzhaosheng* @date 2024/1/14 17:25:01* @description 享元工厂类* 作用: 作为存储享元对象的享元池.用户获取享元对象时先从享元池获* 取,有则返回,没有创建新的享元对象返回给用户,并在享元池中保存新增的对象.*/
public class FlyweightFactory {//定义一个HashMap用于存储享元对象,实现享元池private Map<String, Flyweight> pool = new HashMap();public FlyweightFactory() {//添加对应的内部状态pool.put("A", new ConcreteFlyweight("A"));pool.put("B", new ConcreteFlyweight("B"));pool.put("C", new ConcreteFlyweight("C"));}//根据内部状态来进行查找public Flyweight getFlyweight(String key) {//对象存在,从享元池直接返回if (pool.containsKey(key)) {System.out.println("===享元池中存在,直接复用,key:" + key);return pool.get(key);} else {//如果对象不存在,先创建一个新的对象添加到享元池中,然后返回System.out.println("===享元池中不存在,创建并复用, key:" + key);Flyweight fw = new ConcreteFlyweight(key);pool.put(key, fw);return fw;}}
}二、享元模式的应用
2.1 需求说明
五子棋中有大量的黑子和白子，它们的形状大小都是一样的,只是出现的位置不同，所以一个棋子作为一个独立的对象存储在内存中，会导致大量的内存的浪费，我们使用享元模式来进行优化。
2.2 需求实现
2.2.1 类图
2.2.2 具体实现
2.2.2.1 抽象享元类
package main.java.cn.test.flyweight.V2;/*** @author ningzhaosheng* @date 2024/1/14 17:34:28* @description 抽象享元类: 五子棋类*/
public abstract class GobangFlyweight {public abstract String getColor();public void display() {System.out.println("棋子颜色: " + this.getColor());}}2.2.2.2 共享享元类-白色棋子
package main.java.cn.test.flyweight.V2;/*** @author ningzhaosheng* @date 2024/1/14 17:35:10* @description 共享享元类-白色棋子*/
public class WhiteGobang extends GobangFlyweight{@Overridepublic String getColor() {return "白色";}
}
2.2.2.3 共享享元类-黑色棋子
package main.java.cn.test.flyweight.V2;/*** @author ningzhaosheng* @date 2024/1/14 17:35:45* @description 共享享元类-黑色棋子*/
public class BlackGobang extends GobangFlyweight {@Overridepublic String getColor() {return "黑色";}
}2.2.2.4 享元工厂类
package main.java.cn.test.flyweight.V2;import java.util.HashMap;
import java.util.Map;/*** @author ningzhaosheng* @date 2024/1/14 17:36:19* @description 享元工厂类-生产围棋棋子,使用单例模式进行设计*/
public class GobangFactory {private static GobangFactory factory = new GobangFactory();private static Map<String, GobangFlyweight> pool;//设置共享对象的内部状态,在享元对象中传递private GobangFactory() {pool = new HashMap<String, GobangFlyweight>();GobangFlyweight black = new BlackGobang(); //黑子GobangFlyweight white = new WhiteGobang(); //白子pool.put("b", black);pool.put("w", white);}//返回享元工厂类唯一实例public static final GobangFactory getInstance() {return SingletonHolder.INSTANCE;}//静态内部类-单例private static class SingletonHolder {private static final GobangFactory INSTANCE = new GobangFactory();}//通过key获取集合中的享元对象public GobangFlyweight getGobang(String key) {return pool.get(key);}}2.2.2.5 测试类
package main.java.cn.test.flyweight.V2;/*** @author ningzhaosheng* @date 2024/1/14 17:37:45* @description 测试类*/
public class Test {public static void main(String[] args) {//获取享元工厂对象GobangFactory instance = GobangFactory.getInstance();//获取3颗黑子GobangFlyweight b1 = instance.getGobang("b");GobangFlyweight b2 = instance.getGobang("b");GobangFlyweight b3 = instance.getGobang("b");System.out.println("判断两颗黑子是否相同: " + (b1 == b2));//获取2颗白子GobangFlyweight w1 = instance.getGobang("w");GobangFlyweight w2 = instance.getGobang("w");System.out.println("判断两颗白子是否相同: " + (w1 == w2));//显示棋子b1.display();b2.display();b3.display();w1.display();w2.display();}
}
三、享元模式总结
3.1 享元模式的优点
- 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
比如，当大量商家的商品图片、固定文字（如商品介绍、商品属性）在不同的网页进行展示时，通常不需要重复创建对象，而是可以使用同一个对象，以避免重复存储而浪费内存空间。由于通过享元模式构建的对象是共享的，所以当程序在运行时不仅不用重复创建，还能减少程序与操作系统的 IO 交互次数，大大提升了读写性能。
- 享元模式中的外部状态相对独立，且不影响内部状态
3.2 享元模式的缺点
- 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂
3.3 享元模式的适用场景
- 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
注意: 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。
- 在 Java 中，享元模式一个常用的场景就是，使用数据类的包装类对象的valueOf() 方法。
比如，使用 Integer.valueOf() 方法时，实际的代码实现中有一个叫 IntegerCache 的静态类，它就是一直缓存了 -127 到 128 范围内的数值，如下代码所示，你可以在 Java JDK 中的 Integer 类的源码中找到这段代码。
package main.java.cn.test.flyweight.V2;/*** @author ningzhaosheng* @date 2024/1/14 17:47:05* @description*/
public class Test1 {public static void main(String[] args) {Integer i1 = 127;Integer i2 = 127;System.out.println("i1和i2对象是否是同一个对象？" +(i1 == i2));Integer i3 = 128;Integer i4 = 128;System.out.println("i3和i4对象是否是同一个对象？" +(i3 == i4));}//传入的值在-128 - 127 之间,直接从缓存中返回public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}
}可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。其实享元模式本质上就是找到对象的不可变特征，并缓存起来，当类似对象使用时从缓存中读取，以达到节省内存空间的目的。
好了，本次分享就到这里，欢迎大家继续阅读《设计模式》专栏其他设计模式内容，如果有帮助到大家，欢迎大家点赞+关注+收藏，有疑问也欢迎大家评论留言！
