设计模式之享元模式
享元模式的目的是复用。复用那些细粒度的小对象，从而减少系统中对象的数量，提高系统性能。
模式的关键：
1. 分清内蕴状态(可共享，对象一旦创建就不能改变)和外蕴状态(不可共享，又外部环境负责维护)
2. FlyweightFactory工厂的存在把获取享元对象的过程封装起来。该工厂一般设计为单例模式。
分为单纯享元模式和复合享元模式。
一、单纯享元模式
1.1 不带外蕴状态的享元模式
import java.util.HashMap;
import java.util.Map;
// 不带外蕴状态的单纯享元模式
public class Test5 {
public static void main(String[] args) {
FlyweightFactory factory = FlyweightFactory.getInstance();
Flyweight cf1 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf1.show();
Flyweight cf2 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_B);
cf2.show();
Flyweight cf3 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf1.show();
}
}
// 抽象享元
abstract class Flyweight {
public abstract void show ();
}
// 具体享元类
class ConcreteFlyweight extends Flyweight {
private char value; // 内蕴状态，对象创建后，内蕴状态就不再改变。因此，具体享员类一般设计为不变类。
public ConcreteFlyweight(char internalState) {
this.value = internalState;
}
@Override
public void show() {
System.out.println("字母：" + this.value);
}
}
class FlyweightFactory {
// singleton
private static final FlyweightFactory instance = new FlyweightFactory();
private Map<String, Flyweight> cache = new HashMap<String, Flyweight>();
public static final String KEY_CHAR_A = "A";
public static final String KEY_CHAR_B = "B";
private FlyweightFactory () {}
public static FlyweightFactory getInstance() {
return instance;
}
public Flyweight getFlyweight(String key) {
if (cache.get(key) != null) {
return cache.get(key);
}
if (key.equals(KEY_CHAR_A)) {
cache.put(KEY_CHAR_A, new ConcreteFlyweight('A'));
return cache.get(key);
} else if (key.equals(KEY_CHAR_B)) {
cache.put(KEY_CHAR_B, new ConcreteFlyweight('B'));
return cache.get(key);
}
return null;
}
}
// 运行结果： (请求了3次，但是只生成了2个对象)
字母：A
字母：B
字母：A
1.2. 带外蕴状态的享元模式
import java.util.HashMap;
import java.util.Map;
// 带外蕴状态的单纯享元模式
public class Test5 {
public static void main(String[] args) {
FlyweightFactory factory = FlyweightFactory.getInstance();
Flyweight cf1 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf1.show(" 字体：宋体"); // 外部状态由客户端维护
Flyweight cf2 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_B);
cf2.show(" 大小：12px");
Flyweight cf3 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf3.show(" 字体：隶书");
}
}
// 抽象享元
abstract class Flyweight {
public abstract void show (String externState); // 业务方法
}
// 具体享元类
class ConcreteFlyweight extends Flyweight {
private char value; // 内蕴状态，对象创建后，内蕴状态就不再改变。因此，具体享员类一般设计为不变类。
public ConcreteFlyweight(char internalState) {
this.value = internalState;
}
// 外部状态通过参数传给享元对象，从而改变享元对象的行为，但是对享元对象的内部状态没有任何影响
@Override
public void show(String externState) {
System.out.println("字母：" + this.value + "; 外部状态【" + externState + "】");
}
}
class FlyweightFactory {
// singleton
private static final FlyweightFactory instance = new FlyweightFactory();
private Map<String, Flyweight> cache = new HashMap<String, Flyweight>();
public static final String KEY_CHAR_A = "A";
public static final String KEY_CHAR_B = "B";
private FlyweightFactory () {}
public static FlyweightFactory getInstance() {
return instance;
}
public Flyweight getFlyweight(String key) {
if (cache.get(key) != null) {
return cache.get(key);
}
if (key.equals(KEY_CHAR_A)) {
cache.put(key, new ConcreteFlyweight('A'));
return cache.get(key);
} else if (key.equals(KEY_CHAR_B)) {
cache.put(key, new ConcreteFlyweight('B'));
return cache.get(key);
}
return null;
}
}运行结果：(请求3次，只生成两个享元对象，但是因为外蕴状态的加入，2个享元对象表现出3种不同的行为)
字母：A; 外部状态【 字体：宋体】字母：B; 外部状态【 大小：12px】
字母：A; 外部状态【 字体：隶书】
1.3 复合享元模式
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
// 复合享元模式
public class Test5 {
public static void main(String[] args) {
FlyweightFactory factory = FlyweightFactory.getInstance();
// 获取单纯享元
Flyweight cf1 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf1.show(" 字体：宋体"); // 外部状态由客户端维护
Flyweight cf2 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_B);
cf2.show(" 大小：12px");
Flyweight cf3 = factory.getFlyweight(FlyweightFactory.KEY_CHAR_A);
cf3.show(" 字体：隶书");
// 获取复合享元
Flyweight composit = factory.getFlyweight(Arrays.asList(new String[]{"A","B","B","B","A"}));
composit.show("粗体、黑色");
}
}
// 抽象享元
abstract class Flyweight {
public abstract void show (String externState); // 业务方法
}
// 具体享元类
class ConcreteFlyweight extends Flyweight {
private char value; // 内蕴状态，对象创建后，内蕴状态就不再改变。因此，具体享员类一般设计为不变类。
public ConcreteFlyweight(char internalState) {
this.value = internalState;
}
// 外部状态通过参数传给享元对象，从而改变享元对象的行为，但是对享元对象的内部状态没有任何影响
@Override
public void show(String externState) {
System.out.println("字母：" + this.value + "; 外部状态【" + externState + "】");
}
}
//复合享元类。
//之所以引入复合享元，是为了把那些外蕴状态相同的单纯享元集中起来进行管理。
class CompositeFlyweight extends Flyweight {
// 持有单纯享元的集合。这些单纯享元的外蕴状态和当前复合享元的外蕴状态相同。
private Map<String, Flyweight> map = new HashMap<String, Flyweight>();
public CompositeFlyweight(){}
public void add(String key, Flyweight flyweight) {
map.put(key, flyweight);
}
public void show(String externState) {
Set<String> set = map.keySet();
for (String key : set) {
map.get(key).show(externState); // 每个具体的享元的外蕴状态和当前复合享元的外蕴状态相同
}
}
}
// 分别提供获取单纯享元和复合享元的方法
class FlyweightFactory {
// singleton
private static final FlyweightFactory instance = new FlyweightFactory();
private Map<String, Flyweight> cache = new HashMap<String, Flyweight>();
public static final String KEY_CHAR_A = "A";
public static final String KEY_CHAR_B = "B";
private FlyweightFactory () {}
public static FlyweightFactory getInstance() {
return instance;
}
// 获取单纯享元对象
public Flyweight getFlyweight(String key) {
if (cache.get(key) != null) {
return cache.get(key);
}
if (key.equals(KEY_CHAR_A)) {
cache.put(key, new ConcreteFlyweight('A'));
return cache.get(key);
} else if (key.equals(KEY_CHAR_B)) {
cache.put(key, new ConcreteFlyweight('B'));
return cache.get(key);
}
return null;
}
// 获取复合享元对象
public Flyweight getFlyweight(List<String> keys) {
CompositeFlyweight composit = new CompositeFlyweight();
for (String key : keys) {
composit.add(key, this.getFlyweight(key)); // 复合享元中的单纯享元还是通过获取单纯享元的方法中得到
}
return composit;
}
}
输出结果：
// 单纯享元
字母：A; 外部状态【 字体：宋体】
字母：B; 外部状态【 大小：12px】
字母：A; 外部状态【 字体：隶书】
// 复合享元
字母：A; 外部状态【粗体、黑色】
字母：B; 外部状态【粗体、黑色】