简介

享元模式也被称为“蝇量模式”，属于结构型设计模式的一种，该模式是运用共享技术有效地最大限度地复用细粒度对象的一种模式。该模式中，以对象的信息状态划分，可以分为内部数据和外部数据。内部数据是对象可以共享出来的信息，这些信息不会随着系统的运行而改变；外部数据则是在不同运行时被标记了不同的值。

该模式常用于系统底层开发，解决系统性能问题。像我们常用的数据库连接池，字符串常量池等……都是使用享元模式来完成的。“池”中存储了我们创建好的对象，当需要时进行判断，如果“池”中有就可以直接从中取出，如果没有就创建一个对象并放到池中。

通过使用这些“池”就可以避免重复创建对象而导致内存浪费的问题，从而提高系统的效率。

优缺点

优点

  • 可以极大减少内存中对象的数量，使得相同或相似对象在内存中只保存一份，从而可以节约系统资源，提高系统性能。

  • 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

缺点

  • 享元模式使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。

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

应用场景

在以下情况下可以考虑使用享元模式：

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

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

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

外部状态和内部状态

使用享元模式就必须要学会区分对象的外部状态和内部状态。

内部状态：

所谓的内部状态指的就是对象中可以共享的信息，这一部分信息存储在享元对象的内部并且不会随着环境而改变。

外部状态：

外部状态与内部状态恰恰相反，它指的是不可以共享的信息。外部状态会随着环境的改变而改变，从而导致该状态必须由客户端进行保存，因为环境的变化是由客户端引发的。

举一个经典的例子，我想大家或多或少都接触过围棋或五子棋游戏。在该游戏中，有黑白两种颜色的棋子和不同的落子位置。在开始游戏后其落子的颜色是固定可以被称为是棋子的内部状态，然而落子的位置却不是固定的，我们就可以认为落子的位置是外部状态。

享元模式的UML类图

UML类图讲解：

FlyWeight：抽象的享元角色，该类定义了具体享元角色需要实现的的方法。 ConcreteFlyWeight：具体的享元角色，实现了抽象享元角色中定义的方法。 UnSharedConcreteFlyWeight角色：不可以共享的内容，通常情况通过方法的入参传递进具体享元角色中（不一定非要继承或实现抽象享元角色）。 FlyWeightFactory：享元工厂角色，该类中定义了一个“池”，提供从中获取和添加对象的方法。 Client：客户端测试类。

示例讲解

城市中随处可见的共享单车就是一个典型的“享元模式”案例，其中单车的品牌是固定的，使用的人是不确定的。下面就让我们用代码来实现一下。

用户类

/**
 * 用户类 => 对应UnSharedConcreteFlyWeight角色
 * 享元模式中的外部状态，因为无法确定是哪个用户在用，所以是不可共享的。
 */
public class User {
​
  private String name;
​
  public User(String name) {
    this.name = name;
  }
​
  public String getName() {
    return name;
  }
​
  public void setName(String name) {
    this.name = name;
  }
}

共享交通工具抽象类

/**
 * 共享交通工具抽象类 => 对应抽象的享元角色
 */
public abstract class SharingVehicle {
​
  /**
   * 使用共享车辆的方法；
   *  通过该方法的入参将不可共享的内容（外部状态）传递进具体享元角色中。
   */
  public abstract void use(User user);
}

共享单车类

/**
 * 共享单车类 => 对应具体的享元角色
 */
public class Bicycle extends SharingVehicle {
​
  // 共享单车的品牌（内部状态）
  private String brand;
​
  public Bicycle(String brand) {
    this.brand = brand;
  }
​
  @Override
  public void use(User user) {
    System.out.println(String.format("%s正在使用%s的共享单车", user.getName(), this.brand));
  }
}

共享单车工厂类

/**
 * 共享单车工厂类 => 对应享元工厂角色
 */
public class BicycleFactory {
​
  // 存放共享单车的池
  private HashMap<String, Bicycle> pool = new HashMap<>();
​
  // 根据单车的品牌获取相应的单车。如果池中没有就创建一个放到池里。
  public Bicycle getBicycleByBrand(String brand) {
    if (!this.pool.containsKey(brand)) {
      // 不存在时创建一个
      this.pool.put(brand, new Bicycle(brand));
    }
    return pool.get(brand);
  }
}

客户端测试类

/**
 * 客户端测试类
 */
public class Client {
​
  public static void main(String[] args) {
    // 创建共享单车工厂
    BicycleFactory bicycleFactory = new BicycleFactory();
​
    // 获取具体品牌的单车
    Bicycle bicycle1 = bicycleFactory.getBicycleByBrand("美团");
    Bicycle bicycle2 = bicycleFactory.getBicycleByBrand("哈啰");
​
    // 使用单车
    bicycle1.use(new User("测试001"));
    bicycle2.use(new User("测试002"));
  }
}

测试结果

测试001正在使用美团的共享单车
测试002正在使用哈啰的共享单车

总结

1、当系统中存在大量对象，这些对象会消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑使用享元模式。

2、使用享元模式可以降低内存的消耗，减少对象的创建，从而提升系统的性能。

3、用于存放共享对象的池可以使用HashMap/Hashtable来实现。

4、各种缓冲池都是享元模式的经典运用场景。

5、外部状态具有固化性，不可随着内部状态的改变而改变。

6、需要通过一个工厂类来控制这些对象。

7、享元模式也大大提高了系统的复杂度，需要分离出内部和外部状态。