16.结构型 - 享元模式 (Flyweight Pattern)

享元模式 (Flyweight Pattern)

享元模式 (flyweight pattern) 的原始定义是：摒弃了在每个对象中保存所有数据的方式，通过共享多个对象所共有的相同状态，从而让我们能在有限的内存容量中载入更多对象。

享元对象分为两类数据：

1. 内部状态: 不可被改变, 可共享
2. 外部状态: 可被改变, 不可共享

例如： 生活中的一个共享单车例子，无论是谁在使用/占用，单车本体：轮子、车架等都是一样，不会改变，这些数据是（内部状态）；而是谁在使用/占用，以及使用的时长，费用等是根据具体人而定的，这些数据是（外部状态）

从这个定义中你可以发现，享元模式要解决的核心问题就是节约内存空间，使用的办法是找出相似对象之间的共有特征，然后复用这些特征。所谓“享元”，顾名思义就是被共享的单元。

UML 类图

代码实例

1.抽象享元对象 (共享单车)

/**  
* 抽象享元对象  
*/
abstract class BikeFlyWeight{
	int state;//使用状态 1=使用中,0未使用 内部状态
	//使用
	abstract void use(String username);
	//归还
	abstract void back();
	//返回使用状态
	public int getState(){
		return this.state;
	}
}

2.具体享元对象 (摩拜单车)

/**
 * 具体享元对象
 */
class MoBikeFlyWeight extends BikeFlyWeight{
	private String bikeId;
	private String username;
	public MoBikeFlyWeight(String bikeId){
		this.bikeId = bikeId;
	}
	@Override
	void use(String username) {
		this.username = username;
		System.out.println(bikeId+" 号单车, "+ username + ", 使用中");
		state = 1;
	}
	@Override
	void back() {
		System.out.println(bikeId+" 号单车, "+ username + ", 已归还");
		state = 1;
	}
}

3.享元工厂 (缓冲池)

它充当一个池子的作用, 客户端从它这里获取享元对象, 以便复用对象;

public class BikeFlyWeightFactory {
    private static BikeFlyWeightFactory instance = new BikeFlyWeightFactory();
    private static BikeFlyWeightFactory getInstance(){return instance; }

    private Set<BikeFlyWeight> pool = new HashSet<>();
    private BikeFlyWeightFactory(){
        //初始化缓存池
        for (int i = 0; i < 5; i++) {
            pool.add( new MoBikeFlyWeight("mo-"+i ));
        }
    }

	public BikeFlyWeight getBike(){
        for (Iterator<BikeFlyWeight> iterator = pool.iterator(); iterator.hasNext(); ) {
            BikeFlyWeight next =  iterator.next();
            if (next.getState() == 0 ){
                return next;
            }
        }
        return null;
    }
}

测试

public static void main(String[] args) {
	BikeFlyWeightFactory instance = getInstance();
	
	BikeFlyWeight bike = instance.getBike();
	bike.use("张三");

	BikeFlyWeight bike2 = instance.getBike();
	bike2.use("李四");

	bike.back();//张三归还

	BikeFlyWeight bike3 = instance.getBike();//张三归还了, 获取到 1 号对象, 复用了资源
	bike3.use("王五");

}
// out
// mo-1 号单车, 张三, 使用中  
// mo-2 号单车, 李四, 使用中  
// mo-1 号单车, 张三, 已归还  
// mo-1 号单车, 王五, 使用中

享元模式 (Flyweight Pattern) 总结

享元模式通过共享技术实现相同或者相似对象的重用,在逻辑上每一个出现的字符都有一个对象与之对应,然而在物理上他们却是共享同一个享元对象.

关键角色

1. 抽象享元对象
2. 具体享元对象
3. 享元工厂

享元模式的优缺点

享元模式的优点

• 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能

  比如，当大量商家的商品图片、固定文字（如商品介绍、商品属性）在不同的网页进行展示时，通常不需要重复创建对象，而是可以使用同一个对象，以避免重复存储而浪费内存空间。由于通过享元模式构建的对象是共享的，所以当程序在运行时不仅不用重复创建，还能减少程序与操作系统的 IO 交互次数，大大提升了读写性能。

• 享元模式中的外部状态相对独立，且不影响内部状态

享元模式的缺点

• 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

享元模式的适用场景

• 一个系统有大量相同或者相似的对象，造成内存的大量耗费。

  注意: 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

• 在 Java 中，享元模式一个常用的场景就是，使用数据类的包装类对象的 valueOf() 方法。比如，使用 Integer.valueOf() 方法时，实际的代码实现中有一个叫 IntegerCache 的静态类，它就是一直缓存了 -127 到 128 范围内的数值，如下代码所示，你可以在 Java JDK 中的 Integer 类的源码中找到这段代码。