设计模式-享元模式

设计模式-享元模式

1、基本介绍

享元模式（Flyweight Pattern）也叫蝇绳模式：运用共享技术有效地支持大量细粒度的对象。

常用于系统底层开发，解决系统的性能问题。像 数据库连接池 ，里面都是创建好的连接对象，在这些连接对象中有我们需要的对象时则直接拿来用，避免重复创建，如果没有我们需要的，则创建一个。

享元模式能够 解决重复对象的内存消费的问题 ，当系统中有大量相对对象，需要缓冲池时。不需要总是创建新的对象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率。
享元模式经典的应用场景就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用。

2、享元模式-UML图

• Flyweight 是抽象的享元对象，它是产品的抽象类，同时定义出了对象的内部状态和外部状态的接口或实现。
• ConcreteFlyweight 是具体的享元角色，它是具体的产品类，实现了抽线角色定义的相关业务。
• UnsharedConcreteFlyweight 是不可共享的角色，一般不会出现在享元工厂。
• FlyweightFactory 是享元工厂类，用于构建享元池（集合），同时提供从池中获取对象的方法。

内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的变化而变化。
外部状态指对象得以依赖的一个标记，是随着环境改变而改变的、不可共享的状态。

举例说明内部状态和外部状态

五子棋、围棋等都有大量的棋子对象，围棋和五子棋只有黑白两色，且形状大小一致，所以棋子的颜色就是棋子的内部状态；而在一场比赛中，各个棋子的差别仅在于它们的位置不同，当我们玩五子棋或围棋时，落子的颜色时固定的，但位置会发生变化，所以棋子的坐标就是棋子的外部状态。

3、享元模式的特点及使用场景

优点

运用享元模式能够极大的减少系统中对象的个数，减少内存消耗。

享元模式使用了外部状态和内部状态。外部状态较为独立，会随着环境的变化而变化，但内部状态是稳定的。享元模式中享元对象能够在不同的环境中被共享。

缺点

由于应用享元模式得区分开对象的外部状态和内部状态，一定程度增加了分析负担。

为了使对象能够被共享，享元模式需要将享元对象的外部状态外部化，而读取外部状态使得运行时间变长。

使用场景

当系统中存在大量的相同或相似对象的时候，由于这类对象的大量使用，会造成系统内存的消耗，可以使用享元模式来降低内存的消耗。

对象的大部分状态都外部化，可以将这些外部状态传入到对象中。

4、代码示例

package edu.virgil.design.flyweight;

/**
 * @description: 享元类的超类
 * @author: virgil
 * @datetime: 2020/7/23 10:37
 */
public abstract class Flyweight {

	/**
	 * 内部状态
	 **/
	public String intrinsic;
	/**
	 * 外部状态
	 **/
	protected final String extrinsic;

	/**
	 * @description: 要求享元角色必须接受外部状态
	 * @author: virgil
	 * @date: 2020/7/23 10:43
	 * @param extrinsic: 外部状态
	 **/
	public Flyweight(String extrinsic) {
		this.extrinsic = extrinsic;
	}

	public String getIntrinsic() {
		return intrinsic;
	}

	public void setIntrinsic(String intrinsic) {
		this.intrinsic = intrinsic;
	}

	/**
	 * @description: 定义业务操作
	 * @author: virgil
	 * @date: 2020/7/23 10:45
	 **/
	public abstract void operate(int extrinsic);


}

package edu.virgil.design.flyweight;

/**
 * @description: 内部状态
 * @author: virgil
 * @datetime: 2020/7/23 10:44
 */
public class ConcreteFlyweight extends Flyweight {

	public ConcreteFlyweight(String extrinsic) {
		super(extrinsic);
	}

	@Override
	public void operate(int extrinsic) {
		System.out.println("具体Flyweight" + extrinsic);
	}

}

package edu.virgil.design.flyweight;

/**
 * @description: 外部状态类
 * @author: virgil
 * @datetime: 2020/7/23 10:47
 */
public class UnsharedConcreteFlyweight extends Flyweight {

	public UnsharedConcreteFlyweight(String extrinsic) {
		super(extrinsic);
	}

	@Override
	public void operate(int extrinsic) {
		System.out.println("不共享的具体Flyweight" + extrinsic);
	}

}

package edu.virgil.design.flyweight;

import java.util.HashMap;

/**
 * @description享元工厂:
 * @author: virgil
 * @datetime: 2020/7/23 10:49
 */
public class FlyweightFactory {

	/**
	 * 定义一个池容器
	 **/
	private static HashMap<String, Flyweight> pool = new HashMap<>();

	public static Flyweight getFlyweight(String extrinsic) {
		Flyweight flyweight = null;
		if (pool.containsKey(extrinsic)) {
			flyweight = pool.get(extrinsic);
			System.out.println("已有" + extrinsic + ", 直接从池中提取");
		} else {
			flyweight = new ConcreteFlyweight(extrinsic);
			pool.put(extrinsic, flyweight);
			System.out.println("创建" + extrinsic + ", 并从池中提取");
		}
		return flyweight;
	}

}

package edu.virgil.design.flyweight;

/**
 * @description: 客户端
 * @author: virgil
 * @datetime: 2020/7/23 10:54
 */
public class Client {

	public static void main(String[] args) {

		int extrinsic = 22;

		Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
		flyweightX.operate(++ extrinsic);

		Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
		flyweightY.operate(++ extrinsic);

		Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
		flyweightZ.operate(++ extrinsic);

		Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
		flyweightReX.operate(++ extrinsic);

		Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
		unsharedFlyweight.operate(++ extrinsic);

	}

}