一、概念
享元模式是对象的结构模式，它以共享的方式高效的支持大量的细粒度对象，减少对象的数量，并达到节约内存的目的。
享元对象能够做到共享的关键，主要是区分了内部状态和外部状态，内部状态是对象是在建立时就已确定了，且它不随环境的改变而有所不同，所以这些内部状态就可以共享，而外部状态是会随着环境的变化而会改变的，不可以共享。所以外部状态必须由客户端保存，当需要时可以传给享元对象。
二、模式动机
当一个系统对于同一个对象类型，有大量的对象实例 ，且这些对象实例里面的状态大部分都可以外部化，而对一些不可变的相同内部状态一组实例，就可以用一个对象代替。这样就可以减少对角的数量，从而达到节约内存目的。
三、模式的结构
角色分析：
FlyWeight：享元接口,通过这个接口Flyweight可以接受并作用于外部状态。通过这个接口传入外部的状态，在享元对象的方法处理过程中可能会使用到这些数据。
ConcreteFlyWeight：具体的享元对象，这些对象必须是可以共享的，需要封装Flyweight的内部状态。
UnsharedConcreteFlyweight：非共享的享元实例对象，并非所有的Flyweight实现对象都需要共享，非共享的享元实现对象通常是共享的享元实例对象的组合。
FlyWeightFactory：主要用来创建并管理共享享元对象，并对外提供访问共享享元对象的接口，它内部往往有一个共享享元对象的实例池，通过这个实例池来实现享元对象的共享。
Client：享元客户端，主要的工作是维持一个对Flyweight对象的引用，通过FlyWeightFactory获取享元对象，并将客户端存储的外部状态作用于享元对象。
代码样例如下：
package flyweight.sample; /**
* 抽像享元角色，所有具体享元角色的超类，通过这个角色享元接收并作用于外部状态
* @ClassName: FlyWeight
* @author beteman6988
* @date 2018年3月31日 上午7:50:48
*
*/
public interface FlyWeight { /**
* 具体业务逻辑
* @Title: operation
* @param @param extrinsicSate 外部状态
* @return void
* @throws
*/
public void operation(String extrinsicSate); } /**
* 享元对象：可以共享的享元对象
* @ClassName: ConcreteFlyWeight
* @author beteman6988
* @date 2018年3月31日 上午7:56:13
*
*/
public class ConcreteFlyWeight implements FlyWeight { private String intrinsicState ; //不依赖于环境改变而改变的内部状态 /**
* 构造方法，传入享元对象的内部状态
* @param intrinsicState：内部状态
*/
public ConcreteFlyWeight(String intrinsicState) {
super();
this.intrinsicState = intrinsicState;
} /**
* 具体业务逻辑
* @Title: operation
* @param @param extrinsicSate 外部状态
* @return void
* @throws
*/
@Override
public void operation(String extrinsicSate) {
//具体业务逻辑
} } import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; /**
* 不需要共享的复合享元对象
*
* @ClassName: UnsharedConcreteFlyWeight
* @author beteman6988
* @date 2018年3月31日 上午8:05:55
*
*/
public class UnsharedConcreteFlyWeight implements FlyWeight { //享元集合 ，主键：代表共享享元的主键 值：共享享元主键代表的共享享元
private Map<String,FlyWeight> flies = new HashMap<String,FlyWeight>(); /**
* 往复合享元对象中添加共享享元
* @Title: add
* @param @param intrinsticState：内部状态（不一定必须是内部状态，只要是代表该共享享元的主键即可）
* @param @param oneFlyWeight
* @return void
* @throws
*/
public void add(String intrinsticState,FlyWeight oneFlyWeight) {
this.flies.put(intrinsticState,oneFlyWeight);
} /**
* 作用于所有无享元的具体业务逻辑
* @Title: operation
* @param @param extrinsicSate 外部状态
* @return void
* @throws
*/
@Override
public void operation(String extrinsicSate) {
//具体业务逻辑
} public String toString() {
for(Iterator it=flies.entrySet().iterator();it.hasNext();) {
Map.Entry entry=(Entry) it.next();
System.out.println(entry.getValue());
}
return null;
} } import java.util.HashMap;
import java.util.List;
import java.util.Map; /**
* 提供共享享元对象或复合享元对象的工厂
*
* @ClassName: FlyWeightFactory
* @author beteman6988
* @date 2018年3月31日 上午8:24:14
*
*/
public class FlyWeightFactory {
// 共享享元的实例池 ，主键：代表共享享元的主键 值：共享享元主键代表的共享享元
private Map<String, FlyWeight> flies = new HashMap<String, FlyWeight>(); /**
* 返回共享享元对象的工厂方法
* @Title: factory
* @param @param intrinsticState ：内部状态
* @param @return
* @return FlyWeight ：共享享元实例
* @throws
*/
public FlyWeight factory(String intrinsticState) {
// 从实例池获取需要的享元对象
FlyWeight flyWeight = this.flies.get(intrinsticState); if (null == flyWeight) { // 如果获取不到则创建享元对象
flyWeight = new ConcreteFlyWeight(intrinsticState);
this.flies.put(intrinsticState, flyWeight); // 将创建的享元对象添加到实例池
}
return flyWeight;
} /**
* 返回不共享的复合享元实例
* @Title: factory
* @param @param intrinsticStates
* @param @return
* @return FlyWeight
* @throws
*/
public FlyWeight factory(List<String> intrinsticStates) {
UnsharedConcreteFlyWeight unsharedFlyWeight=new UnsharedConcreteFlyWeight(); //创建不共享的复合享元
for(String intrinsticState:intrinsticStates) {
unsharedFlyWeight.add(intrinsticState, this.factory(intrinsticState));
}
return unsharedFlyWeight;
} } import java.util.ArrayList;
import java.util.List; public class Client { public static void main(String[] args) {
FlyWeightFactory factory =new FlyWeightFactory(); List list=new ArrayList();
list.add("a");
list.add("a"); FlyWeight three=factory.factory(list);
System.out.println(three); FlyWeight one=factory.factory("a");
FlyWeight two=factory.factory("a");
System.out.println(one);
System.out.println(two); }
}
代码运行结果如下：
flyweight.sample.ConcreteFlyWeight@15db9742
null
flyweight.sample.ConcreteFlyWeight@15db9742
flyweight.sample.ConcreteFlyWeight@15db9742
通过结果可以看出，三个对象的hashcode相同，说明是同一个对象。
四、模式样例
通过分析Integer.valueOf(int i)来分析JDK(JDK1,8.0.131)享元设计模式，首先分析Integer这个类是否可以做为一个享元的实现类，如下图：
可以看出这个类的内部状态为final的value，且这个值是通过构造函数传入，因为它是final int，所以它的值是不随环境的改变而受到影响的，所以Integer类可以做为享元对象的实现类来使用。
再来看valueOf(int i)函数：
可以看出如果传入的值>=IntegerCache.low且<=IntegerCache.high ,那么就直接从IntegerCache.cache[i + (-IntegerCache.low)]里直接去取对象，而不是新建对象，从而实现对象的共享。
再来看一下IntegerCache这个类，如下图：
可以看出它是Integer类的一个静态私有内部类，它有一个static final Integer cache[]的成员，且这成员变量在类加载时通过静态初始化块（语句2）将256（从上面的代码可以看出 是从 -128到127 共256个Integer对象）个Integer对象初始化到了cache[]数组里面，只要Integer类通过静态方法public static Integer valueOf(int i) 就可以直接从这个cache[]里面取到对应int值的Integer对象（前提是int i值的范围也是-128到127 ，但是这个缓存数组的大小也是可以改变的，通过语句3 ，在JDK的参数里面设置-Djava.lang.Integer.IntegerCache.high=整数值，就可以改变大小，但是这个值不能小于127，如果小于127会取缺省的127 ）。
五、与其它模式的关系
享元模式与单例模式：这两个模式可以组合使用。通常情况下，享元模式中的享元工厂可以实现成为单例模式。
享元模式与组合模式：这两个模式也是可以组合使用的。在享元模式中，存在不需要共享的实现，这些不需要共享的享元通常是对共享的享元对象的组合对象。也就是说，享元模式通常会和组合模式组合使用，来实现更复杂的对象层次结构。