设计模式之工厂模式

Posted 2021-07-31 二木成林

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式之工厂模式相关的知识，希望对你有一定的参考价值。

问题引入

需求，设计一个咖啡店点餐系统。设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。其UML类图如下：

实现代码如下：

Coffee.java

public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}

AmericanCoffee.java

public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

LatteCoffee.java

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

CoffeeStore.java

public class CoffeeStore {

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 加配料
        coffee.addSugar();
        coffee.addMilk();
        // 返回
        return coffee;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        // 生产美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee("american");
        System.out.println(americanCoffee.getName());
        // 生产拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee("latte");
        System.out.println(latteCoffee.getName());
    }
}

假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

概述

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式不在 GoF 23 种设计模式之列。

结构

简单工厂模式的主要角色如下：

简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

将上例用简单工厂模式改造后的UML类图如下：

代码

实现代码如下：

Coffee.java

public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}

AmericanCoffee.java

public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

LatteCoffee.java

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

SimpleCoffeeFactory.java

public class SimpleCoffeeFactory {
    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 不需要加配料，加配料是咖啡店应该做的事情
        // 返回
        return coffee;
    }
}

CoffeeStore.java

public class CoffeeStore {

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 从简单咖啡工厂拿取生产的咖啡
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        // 调用工厂的方法生产咖啡
        Coffee coffee = factory.orderCoffee(type);
        // 加配料
        coffee.addSugar();
        coffee.addMilk();
        // 返回
        return coffee;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        // 生产美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee("american");
        System.out.println(americanCoffee.getName());
        // 生产拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee("latte");
        System.out.println(latteCoffee.getName());
    }
}

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和商品对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。

优缺点

优点

工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

扩展：静态工厂

在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

    public static Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 不需要加配料，加配料是咖啡店应该做的事情
        // 返回
        return coffee;
    }

工厂方法模式

概述

针对简单工厂模式的缺点，使用工厂方法模式就可以解决问题，可以使系统在不修改原来代码的情况下引进新的产品，完全遵循开闭原则。

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

结构

工厂方法模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

将上例改造为工厂方法模式的代码，其UML类图如下：

代码

实现代码如下：

Coffee.java

public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}

AmericanCoffee.java

public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

LatteCoffee.java

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

CoffeeFactory.java

public interface CoffeeFactory {
    /**
     * 创建咖啡对象的方法
     *
     * @return 返回创建的咖啡对象
     */
    Coffee createCoffee();
}

AmericanCoffeeFactory.java

public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        // 生产美式咖啡
        return new AmericanCoffee();
    }
}

LatteCoffeeFactory.java

public class LatteCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        // 生产拿铁咖啡
        return new LatteCoffee();
    }
}

CoffeeStore.java

public class CoffeeStore {
    private CoffeeFactory factory;

    public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
        this.factory = coffeeFactory;
    }

    /**
     * 点咖啡
     * @return
     */
    public Coffee orderCoffee(){
        // 通过工厂生产咖啡
        Coffee coffee = factory.createCoffee();
        // 加配料
        coffee.addMilk();
        coffee.addSugar();
        // 返回
        return coffee;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        // 1.创建咖啡店对象
        CoffeeStore coffeeStore = new CoffeeStore();

        // 2.生成美式咖啡
        // 2.1创建美式工厂类对象
        AmericanCoffeeFactory americanCoffeeFactory = new AmericanCoffeeFactory();
        // 2.2为咖啡店设置工厂类
        coffeeStore.setCoffeeFactory(americanCoffeeFactory);
        // 2.3生成美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee();
        // 2.4打印咖啡名称
        System.out.println(americanCoffee.getName());

        // 3.生成拿铁咖啡
        // 3.1创建拿铁工厂类对象
        LatteCoffeeFactory latteCoffeeFactory = new LatteCoffeeFactory();
        // 3.2为咖啡店设置工厂类
        coffeeStore.setCoffeeFactory(latteCoffeeFactory);
        // 3.3生成拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee();
        // 3.4打印咖啡名称
        System.out.println(latteCoffee.getName());
    }
}

优缺点

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度
抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景：

客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
客户不关心创建产品的细节，只关心产品的品牌

抽象工厂模式

概述

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、传智播客只培养计算机软件专业的学生等。

这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

看下图，可能对同一产品族有清晰的认知：

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

结构

抽象工厂模式的主要角色如下：

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

还是上例，现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。UML类图如下：

实现代码如下：

Coffee.java

public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}

AmericanCoffee.java

public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

LatteCoffee.java

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

Dessert.java

public abstract class Dessert {
    public abstract void show();
}

Tiramisu.java

public class Tiramisu extends Dessert {
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}

MatchaMousse.java

public class MatchaMousse extends Dessert {
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}

DessertFactory.java

public interface DessertFactory {
    /**
     * 生产咖啡
     *
     * @return
     */
    Coffee createCoffee();

    /**
     * 生产甜点
     *
     * @return
     */
    Dessert createDessert();
}

ItalyDessertFactory.java

public class ItalyDessertFactory implements DessertFactory {
    @Override
    public Coffee createCoffee() {
        // 返回意大利风味的拿铁咖啡
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        // 返回意大利风味的提拉米苏
        return new Tiramisu();
    }
}

AmericanDessertFactory.java

public class AmericanDessertFactory implements DessertFactory {

    @Override
    public Coffee createCoffee() {
        // 生产美式风味的咖啡
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        // 生产美式风味的抹茶慕斯
        return new MatchaMousse();
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        // 创建的是意大利风味甜品工厂对象
        ItalyDessertFactory factory = new ItalyDessertFactory();
        // 获取拿铁咖啡和提拉米苏甜品
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();
        // 打印结果
        System.out.println(coffee.getName());
        dessert.show();
    }
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

使用场景：

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

模式扩展：简单工厂+配置文件

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。 Spring中有源码就采用了这种方式。

第一步，定义配置文件

我们使用properties文件作为配置误文件，名称为bean.properties

american=工厂模式.模式扩展.AmericanCoffee
latte=工厂模式.模式扩展.LatteCoffee

第二步，改造工厂类

public class SimpleCoffeeFactory {

    private static Map<String, Coffee> map = new HashMap<>();

    // 静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次。
    static {
        Properties prop = new Properties();
        InputStream is = SimpleCoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            prop.load(is);
            // 遍历properties集合对象
            Set<Object> keySet = prop.keySet();
            for (Object key : keySet) {
                // 根据键获取值，全类名
                String className = prop.getProperty((String) key);
                // 根据全类名加载字节码对象
                Class clazz = Class.forName(className);
                Coffee obj = (Coffee) clazz.newInstance();
                map.put((String) key, obj);
            }
        } catch (IOException | IllegalAccessException | InstantiationException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public static Coffee orderCoffee(String type) {
        // 根据type生产不同的咖啡，不过从bean.properties中加载
        return map.get(type);
    }
}

一样能够成功使用。

源码引用

在JDK中的Collection.iterator()方法底层就使用了抽象工厂模式。

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("令狐冲");
        list.add("风清扬");
        list.add("任我行");

        //获取迭代器对象
        Iterator<String> it = list.iterator();
        //使用迭代器遍历
        while(it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

上面的代码大家应该很熟，使用迭代器遍历集合，获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式。

Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。

注意：

DateForamt类中的getInstance()方法使用的是工厂模式；
Calendar类中的getInstance()方法使用的是工厂模式；

以上是关于设计模式之工厂模式的主要内容，如果未能解决你的问题，请参考以下文章

Delphi 设计模式：《HeadFirst设计模式》Delphi7代码---工厂模式之简单工厂