概念
享元模式（Flyweight Pattern）又称为轻量级模式，是对象池的一种实现。类似于线程池，线程池可以避免不停地创建和销毁多个对象，消耗性能。提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗，属于结构型模式。
享元模式将一个对象的状态分为内部状态和外部状态，内部状态即是不变的，外部状态是变化的，通过共享不变的部分，达到减少对象数量并节约内存的目的。本质是缓存共享对象，降低内存消耗。
类图
类图.png
角色
- 抽象享元角色（Flyweight）：享元对象抽象基类或者接口，同时定义出对象的外部状态和内部状态的接口或实现；
- 具体享元角色（ConcreteFlyweight）：实现抽象角色定义的业务。该角色的内部状态处理应该与环境无关，不能出现会有一个操作改变内部状态，同时修改了外部状态；
- 享元工厂（FlyweightFactory）：负责管理享元对象池和创建享元对象。
通用写法
创建抽象享元接口
public interface IFlyWeight {
void operation(String extrinsicState);
}
创建具体享元类
public 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);
}
}
创建享元工厂：
public 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);
}
}
测试调用代码：
public class Client {
public static void main(String[] args) {
IFlyWeight flyweight1 = FlyWeightFactory.getFlyweight("aa");
IFlyWeight flyweight2 = FlyWeightFactory.getFlyweight("bb");
flyweight1.operation("a");
flyweight2.operation("b");
IFlyWeight flyweight3 = FlyWeightFactory.getFlyweight("aa");
flyweight3.operation("c");
}
}
运行结果：
Object address: 460141958
IntrinsicState: aa
ExtrinsicState: a
Object address: 1163157884
IntrinsicState: bb
ExtrinsicState: b
Object address: 460141958
IntrinsicState: aa
ExtrinsicState: c
内部状态和外部状态
享元模式的定义提出了两个要求：细粒度和共享对象。因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时就将这些对象的信息分为两个部分：内部状态和外部状态。
- 内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变
- 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态
优点
- 减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率
- 减少内存之外的其他资源占用
缺点
- 关注内、外部状态、关注线程安全问题
- 使系统、程序的逻辑复杂化
实际案例
查询火车票时，需要填写出发站、目的站、座位类别等信息，可以通过创建享元对象提高查询效率。
创建 ITicket 接口：
public interface ITicket {
void showInfo(String bunk);
}
创建 TrainTicket 接口：
public 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( this.from + "->" + this.to + "," + bunk + ":" + this.price);
}
}
创建 TicketFactory 类：
public class TicketFactory {
private static Map pool = new ConcurrentHashMap();
public static ITicket queryTicket(String from, String to) {
String key = from + "->" + to;
if (TicketFactory.pool.containsKey(key)) {
System.out.println("使用缓存：" + key);
return TicketFactory.pool.get(key);
}
System.out.println("首次查询，创建对象: " + key);
ITicket ticket = new TrainTicket(from, to);
TicketFactory.pool.put(key, ticket);
return ticket;
}
}
客户端代码：
public class Client {
public static void main(String[] args) {
ITicket ticket = TicketFactory.queryTicket("北京西", "长沙");
ticket.showInfo("硬座");
ticket = TicketFactory.queryTicket("北京西", "长沙");
ticket.showInfo("软座");
ticket = TicketFactory.queryTicket("北京西", "长沙");
ticket.showInfo("硬卧");
}
}
运行结果：
首次查询，创建对象: 北京西->长沙
北京西->长沙,硬座:43
使用缓存：北京西->长沙
北京西->长沙,软座:246
使用缓存：北京西->长沙
北京西->长沙,硬卧:174
再比如，我们经常使用的数据库连接池，因为我们使用 Connection 对象时主要性能消耗在建立连
接和关闭连接的时候，为了提高 Connection 在调用时的性能，我们和将 Connection 对象在调用前创建好缓存起来，用的时候从缓存中取值，用完再放回去，达到资源重复利用的目的。来看下面的代码：
public class ConnectionPool {
private Vector pool;
private String url = "jdbc:mysql://localhost:3306/test";
private String username = "root";
private String password = "root";
private String driverClass = "com.mysql.jdbc.Driver";
private int poolSize = 100;
public ConnectionPool() {
pool = new Vector(poolSize);
try {
Class.forName(driverClass);
for (int i = 0; i < poolSize; i++) {
Connection conn = DriverManager.getConnection(url, username, password);
pool.add(conn);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public synchronized Connection getConnection() {
if ( pool.size()>0 ) {
Connection conn = pool.get(0);
pool.remove(conn);
return conn;
}
return null;
}
public synchronized void release(Connection conn) {
pool.add(conn);
}
}
应用场景
当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多处需要使用的地方，避免大量同一对象的多次创建，消耗大量内存空间。
享元模式其实就是工程模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法生成对象的，只不过享元模式中为工厂方法增加了缓存这一功能，主要总结为以下应用场景：
- 常常应用于系统底层的开发，以便解决系统的性能问题
- 系统有大量相似对象、需要缓冲池的场景