设计模式共享对象（享元模式）享元模式

1.基本介绍

也叫蝇量模式：运用共享技术有效的支持大量细粒度对象
常用于系统底层开发，解决系统性能问题，比如数据库连接池，可以将共用对象直接拿出来用，避免重新创建
能够解决重复对象的内存浪费问题，当系统中有大量相似对象，需要缓冲池时，不需要重新创建，直接从缓冲池中获取
享元模式是池技术的重要实现，String常量池、数据库连接池、缓冲池

2.原理类图

设计模式共享对象（享元模式）
享元模式

FlyWeightFactory：享元的工厂类，用于构建一个池容器（集合），同时提供从池中获取对象方法
FlyWeight：抽象的享元角色，是产品的抽象，同时定义出对象的外部状态 和内部状态 的接口或实现
concreteFlyWeight：具体的享元角色，实现抽象角色定义相关业务
unSharedConcreteFlyWeight：不可共享角色，一般不会出现在享元工厂中

3.内部状态和外部状态

享元模式提出了两个要求：细粒度和共享对象；这里就涉及到内部状态和外部状态了，即将信息分成了两个部分

内部状态

对象共享出来的信息，存储在享元对象内不会随着环境的变化而变化
以围棋为例，棋子的颜色无论是谁来下棋，都是黑白，属于较为稳定的信息，因此颜色可视为内部状态

外部状态

对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态
以围棋为例，每个棋子的坐标是会根据下棋人的不同而不同的，属于不稳定的信息，因此坐标可视为外部状态

小结

即假设开发一个围棋的游戏，一共361个棋子，传统模式就是创建361个棋子对象，而使用享元模式我们只需要两个实例，一黑一白，加上外部状态的位置即可

4.案例

案例需求

网站外包，根据不同的用户来提供它们需要的网站

案例类图设计

设计模式共享对象（享元模式）
享元模式

案例代码实现

WebSite设计实现

public interface WebSite {
	//网站调用方法，即享元角色的使用
	public void use(User user);
}

ConcreteWebSite实现

public class ConcreteWebSite implements WebSite{
	//网站发布的形式，享元角色的内部状态
	private String type = "";
	public ConcreteWebSite(String type) {
		this.type = type;
	}
	@Override
	public void use(User user) {
		System.out.println("网站以【"+type+"】的形式使用中...【使用者："+user.getName()+"】");
	}

}

WebSiteFactory工厂实现

public class WebSiteFactory {
	//模拟一个池
	private HashMap<String, WebSite> pool = new HashMap<>();
	//从池中取出享元角色，没有则创建放入
	public WebSite getWebSite(String type) {
		if(!pool.containsKey(type)) {
			pool.put(type, new ConcreteWebSite(type));
		}
		return pool.get(type);
	}
}

调用时附加上外部状态

public class Client {
	public static void main(String[] args) {
		//创建享元工厂
		WebSiteFactory factory = new WebSiteFactory();	
		//获取享元角色
		WebSite webSite1 = factory.getWebSite("新闻");
		//使用附加上外部信息
		webSite1.use(new User("Tom"));
		//获取不存在的，直接创建
		WebSite webSite2 = factory.getWebSite("博客");
		//外部信息
		webSite2.use(new User("Lin"));
	}
}

5.Integer中的享元模式分析

Integer的Integer.valueOf()方法在-128~127的范围中使用的是享元模式

首先看到该方法，该方法的调用了享元工厂对象，他将得到的int值获取，判断是否符合池*享对象的范畴，有则返回，没有则新建一个返回

    public static Integer valueOf(int i) {
        //可以发现，在IntegerCache中有对共享资源的一个限制
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache对象充当了一个享元工厂，可以发现最小值为-128，最大值为127，只有在这个范围内才是享元模式管理的范畴

   private static class IntegerCache {
        static final int low = -128;
        static final int high;
       //真正储存Integer对象的容器--池
        static final Integer cache[];
       //静态代码块初始化参数
        static {
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
            //往池中添加-128~127的Inter对象
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
        private IntegerCache() {}
    }

6.小结

“享”代表共享，“元”代表对象
系统有大量对象，且这些对象消耗大量内存，对象的状态大部分可以外部化时，我们就可以考虑选用享元模式
用唯一标识码判断，如果内存中有，则返回这个唯一标识码所表示的对象，用HashMap/HashTable存储
享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
使用享元模式要注意的是，享元模式提高了系统的复杂度，需要分理出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态改变。
注意划分内部状态和外部状态，一般需要一个工厂类加以控制

设计模式共享对象（享元模式） 享元模式