深入探索Java设计模式（四）之享元模式

享元模式适用于需要大量相同类型对象的情况。在此，设计布局可以减少创建多个对象的方式。对象在运行时会消耗资源，因此最好在内存中使用较少的对象。它减少了内存占用并利用了程序的整体性能。本文是在学习完优锐课JAVA架构VIP课程—【框架源码专题】中《学习源码中的优秀设计模式》后写下的学习感悟。通过Java中的一个简单示例深入研究了这种模式。

深入探索Java设计模式（一）之单例模式

深入探索Java设计模式（二）之策略模式

深入探索Java设计模式（三）之装饰器模式

总览

轻量级模式减少了重复数据的使用。通常的做法是将对象设计成细粒度以利用其使用的灵活性。但是，问题是对象在运行时会消耗资源。粒度会不利地影响应用程序的性能，因为需要将运行时对象容纳在更大的内存集中。每个对象不仅消耗内存，而且消耗CPU周期。在这种情况下，轻量化模式可以通过减少细粒度对象的重复实例化来解决。

享元模式Flyweight Pattern

享元模式分为两部分：

• 内部的：这是独立的部分，数据存储在对象中，与享元模式上下文无关。结果，它对于所有相同的固有数据都是可共享的，因此可以用享元模式对象替换。
• 外在的： 这是从属部分，其中保留了举重对象的上下文信息。这是不可共享的。状态由客户端对象存储，并根据要求传递给享元模式对象。

享元模式的使用

在我们有许多表示相同值的对象的情况下，这很有用。因此，它使不可变对象的值可共享。例如，在下面的代码片段中观察Java标准库的Integer包装器类的valueOf()方法如何检查给定参数的值。

 public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
       return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
 }

如果该值先前已缓存，则该方法将返回构造函数实例，而不是创建一个新对象。因为缓存是在静态块中初始化的，所以仅在第一次调用时才创建Integer实例。请注意，IntegerCache类是在Integerclass中定义的私有静态类。

 private static class IntegerCache {
    // ...
    static {
       // ...
       cache = new Integer[(high - low) + 1];
       int j = low;
       for (int k = 0; k < cache.length; k++)
          cache[k] = new Integer(j++);
       // Range [-128, 127] must be interned (JLS7 5.1.7)
       assert IntegerCache.high >= 127;
    }
    // ...
 }

现在，我们可以测试Integer类是否创建两个不同的对象（如果值相同）。将图1中的输出与以下代码进行比较。

 public class JustForTesting {
    public static void main(String[] args){
       final Integer intObj1 = Integer.valueOf(10);
       final Integer intObj2 = Integer.valueOf(10);
       System.out.println("First Case");
       if (intObj1 == intObj2){
          System.out.println("If the values are same " +
             "then the objects are also same.");
       } else {
          System.out.println("If the values are different " +
             "then the objects are also distinct.");
       }
       // Now, if we change the same value to a different
       // value, it becomes two distinct objects

       final Integer intObj3 = Integer.valueOf(10);
       final Integer intObj4 = Integer.valueOf(20);
       System.out.println("Second Case");
       if (intObj3 == intObj4){
          System.out.println("If the values are same " +
             "then the objects are also same.");
       } else {
          System.out.println("If the values are different " +
             "then the objects are also distinct.");
       }
    }
 }

输出

图1：前面代码的输出

实现享元模式

这是享元模式的简单实现。观察如何限制具有相同值的对象创建新对象，而不是提供池中已经存在的对象的副本。工厂中的对象池充当保留享元模式实例的缓存。

 package testpattern;
 public class Car {
    private String color;
    public Car(String color){
       this.color = color;
       System.out.println("Painted with "+color+" color.");
    }
    public String getColor() {
       return color;
    }
 }
 package testpattern;
 import java.util.ArrayList;
 import java.util.List;
 public class CarFactory {
    private List<Car> carpool = new ArrayList<>();
    public Car getFlyweightCar(String color) {
       for (Car c: carpool) {
          if (c.getColor().equals(color)){
             System.out.println(color +
                " car is already in the pool!");
             return c;
          }
       }
       Car car = new Car(color);
       carpool.add(car);
       return car;
    }
 }
 package testpattern;
 public class App {
    public static void main(String[] args) {
       CarFactory cf = new CarFactory();
       cf.getFlyweightCar("RED");
       cf.getFlyweightCar("BLUE");
       cf.getFlyweightCar("GREEN");
       cf.getFlyweightCar("PURPLE");
       cf.getFlyweightCar("RED");
       cf.getFlyweightCar("BLUE");
       cf.getFlyweightCar("BLACK");
    }
 }

输出

图2：享元模式实现的输出

结论

享元模式是在许多情况下使用的常见模式，有时程序员会在不知不觉中使用它。这种模式说明了我们如何使用许多内存不足的对象。如前所述，我们必须始终尽可能利用不变的Integer类的valueOf方法，因为当我们调用new时，即使缓存包含相同的对象，也会创建一个新实例。正如我们已经讨论过的那样，valueOf方法还可以工作。这是使用享元模式的优势。

感谢阅读！欢迎留言。想更深入探讨学习也欢迎私信我。下篇继续~

深入探索Java设计模式（五）之构建器模式