一、定义
运用共享技术有效地支持大量细粒度的对象。又名“蝇量模式”。
说到享元模式，第一个想到的应该就是池技术了。String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式。比如我们每次创建字符串对象时，都需要创建一个新的字符串对象的话，内存开销会很大，所以如果第一次创建了字符串对象"adam"，下次再创建相同的字符串"adam"时，只是把它的引用指向"adam"，这样就实现了"adam"字符串再内存中的共享。
享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的消耗。享元对象能做到共享的关键是区分内部状态（Internal State）和外部状态（External State）。
内部状态是存储在享元对象内部的，不会随环境的改变而改变。内部状态是可以共享的。
外部状态是随环境的改变而改变的、不可以共享的。享元对象的外部状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外部状态不可以影响享元对象的内部状态，他们是相互独立的。
享元模式可以分成单纯享元模式和复合享元模式。
二、单纯享元模式
单纯享元模式包含的角色如下：
抽象享元角色（Flyweight）：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
具体享元角色（ConcreteFlyweight)：实现抽象享元角色所规定出的接口。如果有内部状态的话，必须负责为内部状态提供存储空间。
享元工厂角色（FlyweightFactory)：本角色负责创建和管理（提供一个池容器，通常是HashMap）享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
抽象享元角色：
package com.wuychn.flyweight.pure;
public interface Flyweight {
void operation(String state);
}
具体享元角色：
package com.wuychn.flyweight.pure;
public class ConcreteFlyweight implements Flyweight {
private String str;
public ConcreteFlyweight(String str) {
this.str = str;
}
public void operation(String state) {
System.out.println("内部状态：" + str);
System.out.println("外部状态：" + state);
}
}
享元工厂角色：
package com.wuychn.flyweight.pure;
import java.util.HashMap;
import java.util.Map;
public class FlyWeightFactory {
private Map<String, ConcreteFlyweight> flyWeights = new HashMap<String, ConcreteFlyweight>();
public ConcreteFlyweight get(String str) {
ConcreteFlyweight flyweight = flyWeights.get(str);
if (flyweight == null) {
flyweight = new ConcreteFlyweight(str);
flyWeights.put(str, flyweight);
}
return flyweight;
}
public int getFlyWeightSize() {
return flyWeights.size();
}
}
测试代码：
package com.wuychn.flyweight.pure;
public class Test {
public static void main(String[] args) {
FlyWeightFactory factory = new FlyWeightFactory();
Flyweight f1 = factory.get("a");
Flyweight f2 = factory.get("b");
Flyweight f3 = factory.get("a");
f1.operation("a fly weight");
f2.operation("b fly weight");
f3.operation("c fly weight");
System.out.println(f1 == f3);
System.out.println(factory.getFlyWeightSize());
}
}
结果：
内部状态：a
外部状态：a fly weight
内部状态：b
外部状态：b fly weight
内部状态：a
外部状态：c fly weight
true
2
三、复合享元模式
在单纯享元模式中，所有的享元对象都是单纯享元对象，也就是说都是可以直接共享的，将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。
复合享元模式包含的角色如下：
抽象享元角色（Flyweight）：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
具体享元角色（ConcreteFlyweight)：实现抽象享元角色所规定出的接口。如果有内部状态的话，必须负责为内部状态提供存储空间。
复合享元角色（ConcreteCompositeFlyweight)：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。
享元工厂角色（FlyweightFactory)：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
抽象享元角色和具体享元角色代码同单纯享元模式。
复合享元对象是由单纯享元对象通过复合而成的，因此提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的：
package com.wuychn.flyweight.composite;
import com.wuychn.flyweight.pure.Flyweight;
import java.util.HashMap;
import java.util.Map;
public class ConcreteCompositeFlyweight implements Flyweight {
private Map<String, Flyweight> flyWeights = new HashMap<String, Flyweight>();
public void add(String key, Flyweight fly) {
flyWeights.put(key, fly);
}
public void operation(String state) {
Flyweight fly = null;
for (String s : flyWeights.keySet()) {
fly = flyWeights.get(s);
fly.operation(state);
}
}
}
享元工厂角色提供两种不同的方法，一种用于提供单纯享元对象，另一种用于提供复合享元对象：
package com.wuychn.flyweight.composite;
import com.wuychn.flyweight.pure.ConcreteFlyweight;
import com.wuychn.flyweight.pure.Flyweight;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class FlyweightCompositeFactory {
private Map<String, Flyweight> flyWeights = new HashMap<String, Flyweight>();
public Flyweight get(List<String> compositeStates) {
ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();
for (String s : compositeStates) {
compositeFly.add(s, this.get(s));
}
return compositeFly;
}
public Flyweight get(String s) {
Flyweight fly = flyWeights.get(s);
if (fly == null) {
fly = new ConcreteFlyweight(s);
flyWeights.put(s, fly);
}
return fly;
}
}
测试代码：
package com.wuychn.flyweight.composite;
import com.wuychn.flyweight.pure.Flyweight;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("a");
list.add("b");
FlyweightCompositeFactory factory = new FlyweightCompositeFactory();
Flyweight f1 = factory.get(list);
Flyweight f2 = factory.get(list);
f1.operation("Composite Call");
System.out.println("=======");
System.out.println("复合享元模式是否可以共享对象：" + (f1 == f2));
String str = "a";
Flyweight f3 = factory.get(str);
Flyweight f4 = factory.get(str);
System.out.println("单纯享元模式是否可以共享对象：" + (f3 == f4));
}
}
运行结果：
内部状态：a
外部状态：Composite Call
内部状态：b
外部状态：Composite Call
内部状态：c
外部状态：Composite Call
=======
复合享元模式是否可以共享对象：false
单纯享元模式是否可以共享对象：true
由上例可知：一个复合享元对象的所有单纯享元对象元素的外部状态都是与复合享元对象的外部状态相等的。一个复合享元对象所含有的单纯享元对象的内部状态一般是不相等的。复合享元对象是不能共享的。单纯享元对象是可以共享的。
四、优缺点
优点：大幅度降低内存中对象的数量。
缺点：享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。
来源：CSDN
作者：wuychn
链接：https://blog.csdn.net/qmqm011/article/details/103145121