简介
Use sharing to support large numbers of fine-grained objects efficiently.
使用共享对象可有效地支持大量的细粒度的对象。
享元模式（Flyweight）又称为 轻量级模式，它是一种对象结构型模式。
面向对象技术可以很好地解决一些灵活性或可扩展性问题，但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降等问题。享元模式 正是为解决这一类问题而诞生的。
享元模式 是对象池的一种实现。类似于线程池，线程池可以避免不停的创建和销毁多个对象，消耗性能。享元模式 也是为了减少内存的使用，避免出现大量重复的创建销毁对象的场景。
享元模式 的宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。
享元模式 把一个对象的状态分成内部状态和外部状态，内部状态即是不变的，外部状态是变化的；然后通过共享不变的部分，达到减少对象数量并节约内存的目的。
享元模式 本质：缓存共享对象，降低内存消耗
主要解决
当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，消耗大量内存空间。
享元模式 其实就是 工厂模式 的一个改进机制，享元模式 同样要求创建一个或一组对象，并且就是通过工厂方法生成对象的，只不过 享元模式 中为工厂方法增加了缓存这一功能。
优缺点
优点
- 享元模式 可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份，降低内存占用，增强程序的性能；
- 享元模式 的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享；
缺点
- 享元模式 使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化；
- 为了使对象可以共享，享元模式 需要将享元对象的状态外部化，而且外部状态必须具备固化特性，不应该随内部状态改变而改变，否则会导致系统的逻辑混乱；
使用场景
- 系统中存在大量的相似对象；
- 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份；
- 需要缓冲池的场景；
模式讲解
首先来看下 享元模式 的通用 UML 类图：
从 UML 类图中，我们可以看到，享元模式 主要包含三种角色：
- 抽象享元角色（Flyweight）：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现；
- 具体享元角色（ConcreteFlyweight）：实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不能出现会有一个操作改变内部状态，同时修改了外部状态；
- 享元工厂（FlyweightFactory）：负责管理享元对象池和创建享元对象；
以下是 享元模式 的通用代码：
class Client {
public static void main(String[] args) {
IFlyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
IFlyweight flyweight2 = FlyweightFactory.getFlyweight("bb");
flyweight1.operation("a");
flyweight2.operation("b");
}
// 抽象享元角色
interface IFlyweight {
void operation(String extrinsicState);
}
// 具体享元角色
static class ConcreteFlyweight implements IFlyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
@Override
public void operation(String extrinsicState) {
System.out.println("Object address: " + System.identityHashCode(this));
System.out.println("IntrinsicState: " + this.intrinsicState);
System.out.println("ExtrinsicState: " + extrinsicState);
}
}
// 享元工厂
static class FlyweightFactory {
private static Map pool = new HashMap<>();
// 因为内部状态具备不变性，因此作为缓存的键
public static IFlyweight getFlyweight(String intrinsicState) {
if (!pool.containsKey(intrinsicState)) {
IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
pool.put(intrinsicState, flyweight);
}
return pool.get(intrinsicState);
}
}
}
举个例子
例子：我们知道，过年回家的时候很麻烦，因为我们需要抢到一张回家的火车票。抢票的时候，我们肯定是要查询下有没有我们需要的票信息，这里我们假设一张火车的信息包含：出发站，目的站，价格，座位类别。现在要求编写一个查询火车票查询伪代码，可以通过出发站，目的站查到相关票的信息。
直接思路：例子要求通过出发站，目的站查询火车票的相关信息，那么我们只需构建出火车票类对象，然后提供一个查询出发站，目的站的接口给到客户进行查询即可；
具体代码如下：
class Client {
public static void main(String[] args) {
ITicket ticket = TicketFactory.queryTicket("深圳北", "潮汕");
ticket.showInfo("硬座");
}
interface ITicket {
void showInfo(String bunk);
}
static class TrainTicket implements ITicket {
private String from;
private String to;
private int price;
public TrainTicket(String from, String to) {
this.from = from;
this.to = to;
}
@Override
public void showInfo(String bunk) {
this.price = new Random().nextInt(500);
System.out.println(String.format("%s->%s：%s价格：%s 元", this.from, this.to, bunk, this.price));
}
}
static class TicketFactory {
public static ITicket queryTicket(String from, String to) {
return new TrainTicket(from, to);
}
}
}
分析：上面的代码中，客户端进行查询时，系统通过TicketFactory直接创建一个火车票对象，但是这样做的话，当某个瞬间如果有大量的用户请求同一张票的信息时，系统就会创建出大量该火车票对象，系统内存压力骤增。而其实更好的做法应该是缓存该票对象，然后复用提供给其他查询请求，这样一个对象就足以支撑数以千计的查询请求，对内存完全无压力，使用 享元模式 可以很好地解决这个问题；
具体代码如下：只需对上面代码的TicketFactory进行更改，增加缓存机制：
class Client {
public static void main(String[] args) {
ITicket ticket = TicketFactory.queryTicket("深圳北", "潮汕");
ticket.showInfo("硬座");
ticket = TicketFactory.queryTicket("深圳北", "潮汕");
ticket.showInfo("软座");
ticket = TicketFactory.queryTicket("深圳北", "潮汕");
ticket.showInfo("硬卧");
}
...
...
static class TicketFactory {
private static Map sTicketPool = new ConcurrentHashMap<>();
public static ITicket queryTicket(String from, String to) {
String key = from + "->" + to;
if (TicketFactory.sTicketPool.containsKey(key)) {
System.out.println("使用缓存 ==> " + key);
return TicketFactory.sTicketPool.get(key);
}
System.out.println("第一次查询，创建对象 ==> " + key);
ITicket ticket = new TrainTicket(from, to);
TicketFactory.sTicketPool.put(key, ticket);
return ticket;
}
}
}
运行结果如下：
第一次查询，创建对象 ==> 深圳北->潮汕
深圳北->潮汕：硬座价格：429 元
使用缓存 ==> 深圳北->潮汕
深圳北->潮汕：软座价格：321 元
使用缓存 ==> 深圳北->潮汕
深圳北->潮汕：硬卧价格：481 元
可以看到，除了第一次查询创建对象后，后续查询相同车次票信息都是使用缓存对象，无需创建新对象了。