设计模式(11)之工厂模式

一、工厂模式介绍

        工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

        工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

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

二、简单工厂模式(静态工厂模式)

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

        简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

        我们先看具体的实现：我们可以看到，需要注意的是， KuaiCanFood 和 HamburgerFood 都继承自 Food。

public class FoodFactory {
    public static Food makeFood(String name) {
        if ("kuaican".equals(name)) {
            Food kuaican = new KuaiCanFood();
            kuaican.setPrice(20.00);
            return kuaican;
        } 

        if ("hamburger".equals(name)) {
            Food hamburger = new HamburgerFood();
            hamburger.setPrice(22.00);
            hamburger.setMeat("beef");
            return hamburger;
        } 

        // ......

        return new RuntimeException("not food");
    }
}

inteface Food {
}

class HamburgerFood implement Food{

}

class KuaiCanFood  implement Food{

}

        简单地说，简单工厂模式通常就是这样，一个工厂类 XxxFactory，里面有一个静态方法，根据我们不同的参数，返回不同的派生自同一个父类（或实现同一接口）的实例对象。我们强调职责单一原则，一个类只提供一种功能，FoodFactory 的功能就是只要负责生产各种 Food。

        Java 各种框架中，简单工厂模式是非常常见的，比如JedisConnectionFactory。

        基本上 Java 中需要创建连接的框架，都是用了工厂模式。 

2.1优缺点

        优点：

1. 一个调用者想创建一个对象，只要知道其名称就可以了。
2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3. 屏蔽产品的具体实现，调用者只关心产品的接口。

        缺点：

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

2.2 应用场景

        对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

三、工厂方法模式

        上面我们介绍到了简单工厂模式，提到了简单工厂模式违背了开闭原则，而“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

        优点：

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

        缺点：

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

3.1应用场景

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

3.2 应用实例

        简单工厂模式很简单，在一般情况下，它都能满足我们的需要。但是，在某些特殊场景，它就满足不了我们的需求了。还是拿 Redis 为例，Redis 有单机模式，主从模式，哨兵模式，Cluster 模式。每种模式的连接都不一样，因此我们需要引入多个工厂。

        这种情况下，就需要引入多个简单工厂模式。比如：JedisConnectionFactory、JredisConnectionFactory、LettuceConnectionFactory、SrpConnectionFactory等等。之所以需要引入工厂模式，是因为我们往往需要使用两个或两个以上的工厂。

        这里我们还是以Food为例子：

public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if ("套餐A".equals(name)) {
            Food kuaican = new KuaiCanFood();
            kuaican.setPrice(20.00);
            kuaican.setName("快餐");
            return kuaican;
        } 
        
        if ("套餐B".equals(name)) {
            Food mifan = new MiFanFood();
            mifan.setPrice(18.00);
            mifan.setName("五常大米");
            return mifan;
        } 
        
        return null;
    }
}
public class AmericanFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if ("套餐A".equals(name)) {
            Food hamburger = new HamburgerFood();
            hamburger.setPrice(22.00);
            hamburger.setName("hamburger");
            return hamburger;
        } 
        
        if ("套餐B".equals(name)) {
            Food sandwich = new SandwichFood();
            sandwich.setPrice(25.00);
            sandwich.setName("三明治");
            return sandwich;
        } 
        
        return null;
    }
}

        其中，KuaiCanFood、MiFanFood、HamburgerFood、SandwichFood 都派生自 Food。

        消费者调用：

public class Consumer {
    public static void main(String[] args) {
        // 先选择一个具体的工厂
        FoodFactory factory = new ChineseFoodFactory();
        // 由选择的工厂产生具体的对象，不同的工厂造出不一样的对象
        Food food = factory.makeFood("套餐A");
    }
}

           虽然都是调用 makeFood("套餐A")  制作套餐 A，但是，不同的工厂生产出来的完全不一样。第一步，我们需要选取合适的工厂，然后第二步基本上和简单工厂一样。核心在于，我们需要在第一步选好我们需要的工厂。比如，我们有 FileFactory 接口，实现类有 AliyunOssFactory 和 TencentCosFactory，分别对应将文件写入阿里云 OSS 和腾讯云 COS 中。很显然，我们客户端或者消费者第一步就需要决定到底要实例化 AliyunOssFactory 还是 TencentCosFactory，这将决定之后的所有的操作。

        工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

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

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

        其结构图下图 所示。 

 

四、抽象工厂模式

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

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

       所以当涉及到产品族的时候，就需要引入抽象工厂模式了。当一个产品族，存在多个不同类型的产品(比如我上面列举的 Redis 连接工厂)情况下，不同架构模式，选择不同的连接工厂的问题。而这种场景在业务开发中也是非常多见的，只不过可能有时候没有将它们抽象化出来。

4.1模式的定义与特点

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

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

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

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

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

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

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

4.2抽象工厂的模式与实现

        抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

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

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

        抽象工厂模式的结构图下图所示：

     

        模式的实现：从图可以看出抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。下面给出抽象工厂和具体工厂的代码：

     (1) 抽象工厂：提供了产品的生成方法。

interface AbstractFactory {
    public Product1 newProduct1();
    public Product2 newProduct2();
}

   (2) 具体工厂：实现了产品的生成方法。

class ConcreteFactory1 implements AbstractFactory {
    public Product1 newProduct1() {
        System.out.println("具体工厂 1 生成-->具体产品 11...");
        return new ConcreteProduct11();
    }
    public Product2 newProduct2() {
        System.out.println("具体工厂 1 生成-->具体产品 21...");
        return new ConcreteProduct21();
    }
}

         好了。工厂模式讲到这里应该差不多就结束了，最后总结一下，功能模式根据需求和功能的不同，你可以选择对应的简单工厂，普通工厂，和抽象工厂。抽象工厂看起来比较抽象，它暴露的问题也是显而易见的，比如我们要加个 NFC 模块，就需要修改所有的工厂，给所有的工厂都加上制造显示器的方法。这有点违反了对修改关闭，对扩展开放这个设计原则。但也不要完全照搬设计原则，毕竟有时候是需要打破原则，不是吗？比如在电商系统中的一些反范式设计等。