把书读薄 | 《设计模式之美》设计模式与范式（创建型-工厂模式）

0x0、引言

最近稍微没那么忙，继续啃《设计模式之美》，本文是 设计模式与范式：创建型(44-45)，工厂模式(Factory Design Pattern) 也是用的比较多的创建型设计模式~

二手知识加工难免有所纰漏，感兴趣有时间的可自行查阅原文，谢谢。

0x1、定义

一般将工厂模式细分为种：简单工厂、工厂方法 和 抽象工厂，前两个在项目中用得多一些。

适用场景：创建一个对象，但创建过程比较复杂，希望对外隐藏这些细节。

注意！适用于对象创建过程比较复杂的场景，一般是这两类：创建过程涉及复杂的if-else分支判断 和 复杂依赖 (如new A(new B(new C())))，应用工厂模式无疑会带来类文件的增加，简单的场景直接new构造不香吗？

接下来通过一个简单的奶茶店案例来引入这几种模式的使用，先是面向过程(OOP)的写法：

public class TeaStoreTest {
    public static String make(int type) {
        String teaName = null;
        if (type == 0) {
            teaName = "珍珠奶茶";
        } else if (type == 1) {
            teaName = "港式奶茶";
        } else if (type == 2) {
            teaName = "冰奶茶";
        } else if (type == 3) {
            teaName = "冻柠茶";
        }
        return teaName;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            String teaName = make(new Random().nextInt(5));
            if (teaName != null) {
                System.out.println("产出一杯：" + teaName);
            } else {
                System.out.println("本店暂无此款茶饮~");
            }
        }
    }
}
复制代码

运行结果如下：

把奶茶名生成的步骤包裹在make()方法中，传入不同的type，返回不同的奶茶名。接着转换下思路，OOP面向对象思想，可以将这部分逻辑剥离到一个独立的类中，让这个类只负责 奶茶名的创建。

// 生产奶茶的类
public class OldTeaStore {
    public String make(int type) {
        String teaName = null;
        if (type == 0) {
            teaName = "珍珠奶茶";
        } else if (type == 1) {
            teaName = "港式奶茶";
        } else if (type == 2) {
            teaName = "冰奶茶";
        } else if (type == 3) {
            teaName = "冻柠茶";
        }
        return teaName;
    }
}

// 测试用例
public class OldTeaStoreTest {
    public static void main(String[] args) {
        OldTeaStore store = new OldTeaStore();
        for (int i = 0; i < 5; i++) {
            String teaName = store.make(new Random().nextInt(5));
            if (teaName != null) {
                System.out.println("产出一杯：" + teaName);
            } else {
                System.out.println("本店暂无此款茶饮~");
            }
        }
    }
}
复制代码

① 简单工厂 (Simple Factory)

不变的只有变化本身，而需求是不断变化的，现在单单一个奶茶名可不够，可能还要奶茶容量、价格等，基于封装和抽象的思想，我们抽象出一个Tea类，包含一个createTea() 生产奶茶的方法，并实现四个具体的茶类。

// 抽象的茶
public abstract class Tea {
    protected abstract String createTea();
}

// 具体的茶
public class TapiocaMilkTea extends Tea {
    @Override
    protected String createTea() { return "珍珠奶茶"; }
}

public class HKStyleHotTea extends Tea {
    @Override
    protected String createTea() { return "港式奶茶"; }
}

public class IcedMilkTea extends Tea {
    @Override
    protected String createTea() { return "冰奶茶"; }
}

public class IcedLemonTea extends Tea {
    @Override
    protected String createTea() { return "冻柠茶"; }
}
复制代码

接着是生产奶茶的类：

// 创建Tea实例的类
public class NewTeaStore {
    public String exchange(int type) {
        String teaName = "";
        if (type == 0) {
            teaName = "珍珠奶茶";
        } else if (type == 1) {
            teaName = "港式奶茶";
        } else if (type == 2) {
            teaName = "冰奶茶";
        } else if (type == 3) {
            teaName = "冻柠茶";
        }
        return teaName;
    }

    public Tea make(int type) {
        String teaName = exchange(type);
        Tea tea = null;
        if (teaName.equals("珍珠奶茶")) {
            tea = new TapiocaMilkTea();
        } else if (teaName.equals("港式奶茶")) {
            tea = new HKStyleHotTea();
        } else if (teaName.equals("冰奶茶")) {
            tea = new IcedMilkTea();
        } else if (teaName.equals("冻柠茶")) {
            tea = new IcedLemonTea();
        }
        return tea;
    }
}

// 测试用例
public class NewTeaStoreTest {
    public static void main(String[] args) {
        NewTeaStore store = new NewTeaStore();
        for (int i = 0; i < 5; i++) {
            Tea tea = store.make(new Random().nextInt(5));
            if (tea != null) {
                System.out.println("产出一杯：" + tea.createTea());
            } else {
                System.out.println("本店暂无此款茶饮~ ");
            }
        }
    }
}
复制代码

运行结果同上，这就是 简单工厂 模式，由 抽象产品、具体产品、工厂 三个要素组成，工厂内有具体的逻辑去判断生成怎么样的产品。

另外，如果奶茶实例可以服用的话，为了节省内存和对象创建时间，可以将其事先创建好缓存起来，调用createTea()时，从缓存中直接取出parse对象直接使用。

public class NewTeaStore {
    private static final Map<Integer, Tea> cachedTeas = new HashMap<>();

    static {
        cachedTeas.put(0, new TapiocaMilkTea());
        cachedTeas.put(1, new HKStyleHotTea());
        cachedTeas.put(2, new IcedMilkTea());
        cachedTeas.put(3, new IcedLemonTea());
    }

    public Tea make(int type) {
        return cachedTeas.get(type);
    }
}
复制代码

一下子清爽了不少，连exchange()函数都直接省了，当然也不难看出，这两种写法都违背了 开闭原则(OCP)，如果要添加新产品，需要改动NewTeaStore中的代码。不过实际开发中，用不着那么苛刻，如果不需要频繁的新增产品，稍微不符合开闭原则也是可以接受的。

如果是第一种写法，想去掉if分支逻辑，比较经典的处理方法就是利用 多态，对工厂类抽象一波。

② 工厂方法 (Factory Method)

// 工厂抽象
public interface ITeaStore {
    Tea createTea();
}

// 具体工厂
public class TapiocaMilkTeaStore implements ITeaStore{
    @Override
    public Tea createTea() { return new TapiocaMilkTea(); }
}

public class HKStyleHotTeaStore implements ITeaStore {
    @Override
    public Tea createTea() { return new HKStyleHotTea(); }
}

public class IcedMilkTeaStore implements ITeaStore {
    @Override
    public Tea createTea() { return new IcedMilkTea(); }
}

public class IcedLemonTeaStore implements ITeaStore{
    @Override
    public Tea createTea() {
        return new IcedLemonTea();
    }
}

public class NewTeaStore {
    public Tea make(int type) {
        String teaName = exchange(type);
        ITeaStore teaStore = null;
        if (teaName.equals("珍珠奶茶")) {
            teaStore = new TapiocaMilkTeaStore();
        } else if (teaName.equals("港式奶茶")) {
            teaStore = new HKStyleHotTeaStore();
        } else if (teaName.equals("冰奶茶")) {
            teaStore = new IcedMilkTeaStore();
        } else if (teaName.equals("冻柠茶")) {
            teaStore = new IcedLemonTeaStore();
        }
        return teaStore.createTea();
    }
}
复制代码

改动后的结果并没有如我们所愿，跟之前一样耦合，没解决问题反倒使得设计变得更复杂了，一个解决问题的思路就是：为工厂类再创建一个简单工厂，即工厂的工厂，用来创建工厂类对象。

public class TeaStoreFactoryMap {
    private static final Map<Integer, ITeaStore> cachedTeaStores = new HashMap<>();

    static {
        cachedTeaStores.put(0, new TapiocaMilkTeaStore());
        cachedTeaStores.put(1, new HKStyleHotTeaStore());
        cachedTeaStores.put(2, new IcedMilkTeaStore());
        cachedTeaStores.put(3, new IcedLemonTeaStore());
    }

    public static Tea make(int type) {
        return cachedTeaStores.get(type).createTea();
    }
}

// 调用处直接
TeaStoreFactoryMap.make(new Random().nextInt(5));
复制代码

添加新的解析规则，只需创建新的Tea类和TeaStore类，然后将新的TeaStore实例加入到TeaStoreFactoryMap的cachedTeaStores中即可，代码改动非常少，基本符合开闭原则。

不过，在这个简单的场景里，工厂方法模式无疑增加了代码的繁杂性，有点过度设计的味道了，而且每个TeaStore类只是new操作，所以此处用简单工厂模式更佳。

当对象创建逻辑比较复杂，不只是new一下，还要组合其他类做各种初始化操作时，推荐使用工厂方法模式，将复杂的逻辑创建拆分到多个工厂类，让每个工厂类不至于太过复杂。

强调一点：复杂度是无法被消除的，只能被转移，比如上面的if-else，用map后从你的 可视范围 内消除了，实际上是转移到map的get逻辑里了。

③ 抽象工厂 (Abstract Factory)

抽象工厂平时很少用，适用场景：创建的对象有多个相互关联或依赖的产品族，定义：提供了一个用于创建相关或相关对象族的接口，而无须指定其具体类。

说下产品族：同一工厂生产， 位于不同产品等级结构 的一组产品。看不懂？没关系，拆词，显示产品等级结构，举下例子：

Tea是父类，珍珠奶茶、港式奶茶等是子类，这就构成一个产品等级结构；

再举一个例子：

Snack小吃是父类，手抓饼、章鱼小丸子是子类，也构成一个产品等级结构；

Tea和Snack位于不同的产品等级结构，然后是一组产品，怎么理解：

奶茶店现在不卖单品了，卖套餐，茶饮搭配小吃。

此时再看会抽象工厂的适用场景，就不难理解了，抽象工厂由四个角色组成：

• 抽象工厂：声明一组用于创建产品族的方法，每个方法对应一种产品；
• 抽象产品：为每种产品声明接口，声明产品所具有的业务方法；
• 具体工厂：实现抽象工厂创建产品的方法，生成具体的产品；
• 具体产品：抽象产品的具体化，实现方法并进行扩展；

其中最关键的角色是 → 抽象产品，它的好坏直接决定了抽象工厂和具体功能能否发挥最大作用，应用此模式时应该朝着 分析共性规律 的方向走，仔细分析实现类该如何实现。

以上面说的茶和小吃为例写个抽象工厂模式的例子，先是产品类：

// 抽象产品类①
public abstract class Tea {
    protected abstract String createTea();
}

// 抽象产品类②
public abstract class Snack {
    public abstract String createSnack();
}

// 具体产品类(茶类沿用之前的，小吃类新增两个)
public class HandGrab extends Snack {
    @Override
    public String createSnack() { return "手抓饼"; }
}

public class FishBall extends Snack {
    @Override
    public String createSnack() { return "章鱼小丸子"; }
}
复制代码

接着是抽象工厂和测试用例：

// 抽象工厂(套餐)
public abstract class SetMenuFactory {
    public abstract Tea createTeaMaker();
    public abstract factory.Snack createSnackMaker();
}

// 具体工厂①
public class ASetMenuFactory extends SetMenuFactory {
    @Override
    public Tea createTeaMaker() { return new TapiocaMilkTea(); }

    @Override
    public Snack createSnackMaker() { return new HandGrab(); }
}

// 具体工厂②
public class BSetMenuFactory extends SetMenuFactory {
    @Override
    public Tea createTeaMaker() { return new TapiocaMilkTea(); }

    @Override
    public Snack createSnackMaker() { return new FishBall(); }
}

// 测试用例
public class SuperTeaStoreTest {
    public static void main(String[] args) {
        SetMenuFactory factoryFirst = new ASetMenuFactory();
        System.out.println("产出一杯：" + factoryFirst.createTeaMaker().createTea() +
                "和一份：" + factoryFirst.createSnackMaker().createSnack());
        SetMenuFactory factorySecond = new BSetMenuFactory();
        System.out.println("产出一杯：" + factorySecond.createTeaMaker().createTea() +
                "和一份：" + factorySecond.createSnackMaker().createSnack());
    }
}
复制代码

运行结果如下：

抽象工厂的优点：符合开闭原则和单一原则、将使用和创建的代码解耦，增加新的产品系列容易。
抽象工厂的缺点：代码量和学习成本增加，变更产品结构困难，比如上面的套餐，要添加调味包的产品。

0x2、如何设计实现一个DI框架

在讲依赖反转原则(DIP)的时候就提过这几个名词，再粘贴下以便区分：

工厂模式与DI容器的关系

DI容器底层最基本的设计思路就是基于工厂模式的，相当于一个大工厂，负责在程序启动时，根据配置(创建哪些类对象、对象创建需要依赖哪些其他类对象) 事先创建好对象。当程序需要用到某个类对象时，直接从容器中获取即可。正是因为它持有一堆对象，所以这个框架才被称为 “容器”。

DI容器的三个核心功能：

• ① 配置解析：通过一种形式让应用告知DI容器要创建哪些对象，一般通过配置文件形式，如Spring的配置文件；
• ② 对象创建：DI容器根据配置文件提供的信息创建对象，Java中一般通过反射来动态加载类、创建对象；
• ③ 生命周期管理：返回新对象还是复用、是否延迟加载、是否配置对象初始化/销毁的钩子等；

课程中写了一个实现简单DI容器的例子，比较简单，只列下流程：最小原型设计、提供执行入口、配置文件解析、核心工厂类设计。

Android中常见的依赖注入框架有下面几类：

• View注入：XUtils、Android Annotations、ButterKnife
• 参数注入：ARouter
• 对象注入：koin、Dagger2、Hilt

前两类严格意义上不能算真正的注入，本文内容感觉有些单薄，后面会挑一个DI框架的源码进行分析巩固，如无意外应该是Hilt，敬请期待~