学好设计模式防被祭天：蝇量模式

蝇量模式

为了防止被“杀”了祭天，学点设计模式，并总结下还是有必要的。

一：理解

1. 蝇量这个词汇来自于拳击，是比轻量更轻的一个级别。在设计模式中，蝇量表示的是通过减少不必要的对象实例以减小系统的负担。
2. 蝇量模式也称享元模式，享元是共享对象实例(或共享部分属性)的意思。在设计模式中，享元是手段，蝇量是结果。
3. 蝇量模式可以是完全共享和局部共享，完全共享可以减少对象实例，局部共享可以共享不同对象中相同的部分。

二：例子

你是个富二代。

你喜欢开车，然而你比较节俭，每次开车都向租车公司借。

租车公司有汽车对应的接口，包含一个drive方法。

public interface CarI {
    void drive();
}

对于你而言，开什么车其实也没什么，主要是牌子brand要对。

为方便举例，汽车类Car中只包含brand一个属性。

// 汽车类
public class Car implements CarI {
    private String brand;

    public Car(String brand) {
        this.brand = brand;
    }

    @Override
    public void drive() {
        System.out.println("开" + brand + "car");
    }
}

老司机开车代码：

public class Client {
    public static void main(String[] args) {
        Car car1 = new Car("宝马");
        car1.drive();
        Car car2 = new Car("奔驰");
        car2.drive();
        Car car3 = new Car("奥迪");
        car3.drive();
        Car car4 = new Car("宝马");
        car4.drive();
    }
}

你发现，你每次开车之前，都得先租一辆车，即新建一个对象。

例如虽然都是开宝马车，却要新建car1和car4两个对象。

对于高富帅而言，这有点麻烦，也有点不够优雅。

在现实系统中，高并发情况下，每个请求都新建一个对象，会导致内存占用量过大。

高并发时新建过多实例会导致来不及GC或者是GC太频繁。

于是，你叫来程序员小菜帮你解决这个问题。

小菜觉得你作为高富帅，应该在第一次借车的时候，直接把车买下来，下次再开的时候，直接从车库取就可以了。

说到要买买买，作为高富帅的你觉得还是挺有意思的，同意让小菜这么干。

买买买

映射到真实系统，在调用方发起第一次请求时，新建对象并将其保存，之后的请求就无需再新建对象。

小菜决定使用蝇量模式进行重构。

于是，小菜上来就是一顿敲。

就是一把梭

public class CarKeeper {
    private Map<String, Car> carKeeper = Maps.newConcurrentMap();

    public Car getCar(String brand) {
        Car car = carKeeper.get(brand);
        if (car == null) {
            car = new Car(brand);
            carKeeper.put(brand, car);
            System.out.println("新建了" + brand + "car对象!");
        }
        return car;
    }
}

他新建了一个CarKeeper类，该类中包含一个map，用于保存已经建立的Car对象。

该过程和单例模式新建对象类似，为懒加载模式。

不过这里会为每个品牌的车子保存一个实例。

同样的，懒加载会遇到多线程安全问题，可用双重检查解决。

测试代码：

public class ClientV2 {
    public static void main(String[] args) {
        CarKeeper carKeeper = new CarKeeper();
        Car car1 = carKeeper.getCar("宝马");
        car1.drive();
        Car car2 = carKeeper.getCar("奔驰");
        car2.drive();
        Car car3 = carKeeper.getCar("奥迪");
        car3.drive();
        Car car4 = carKeeper.getCar("宝马");
        car4.drive();
        Car car5 = carKeeper.getCar("奔驰");
        car5.drive();
        Car car6 = carKeeper.getCar("奥迪");
        car6.drive();
    }
}

输入/输出：

新建了宝马car对象!
开宝马car
新建了奔驰car对象!
开奔驰car
新建了奥迪car对象!
开奥迪car
开宝马car
开奔驰car
开奥迪car

经过重构，发现只有在第一次借对应品牌车子时才新建对象，之后的请求直接开车就可以了。

你觉得这个模式非常棒，开心地飙起了车。

老司机开车

留下小菜一个人默默地和苍蝇玩耍。

三：再理解

1. 例子中相同牌子的车子可以做到完全共享，使用时直接从map中取出即可。如果不同对象只有局部属性共享，则需要在取出之后，设置一些非共享属性。
2. 该模式共享了对象，执行的方法为无状态的，例如例子中的drive方法只输出字符串。如果方法带状态，需要考虑结果是否正确。
3. 蝇量模式节约了内存空间，减少了对象创建时间。
4. Java中的字符串常量用到了该模式。