工厂模式

在日常开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。

工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

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

简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了开闭原则。

简单工厂优缺点

优点：

• 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。

• 客户端无需知道所创建具体产品的类名，只需知道参数即可。

• 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

• 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，异常会让整个系统受影响

• 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度。

• 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。

• 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

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

模式的结构

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

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

其结构图如下图所示：

模式的实现

根据上图写出该模式的代码如下：

public class Client {
    // 抽象产品
    public interface Product{
        void show();
    }

    // 具体产品A
    static class ConcreteProduct1 implements Product {
        @Override
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    // 具体产品B
    static class ConcreteProduct2 implements Product {
        @Override
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    // 简单工厂类，用于生成产品
    static class SimpleFactory{
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        public static Product makeProduct(int kind){
            switch (kind){
                case PRODUCT_A:
                    return new ConcreteProduct1();
                case PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

测试代码如下所示：

public class Client {
    public static void main(String[] args) {
        Client.Product product1 = Client.SimpleFactory.makeProduct(0);
        Client.Product product2 = Client.SimpleFactory.makeProduct(1);
        product1.show();
        product2.show();
    }
}

工厂方法模式

工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

优点：

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

• 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

• 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类。

缺点：

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

模式的结构

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

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

其结构图如下图所示：

模式实现

上述UML类图的实现如下：

// 抽象产品
public interface Product {
    void show();
}

// 具体产品1
public class ConcreteProduct1 implements Product{
    @Override
    public void show() {
        System.out.println("具体产品1显示...");
    }
}

// 具体产品2
public class ConcreteProduct2 implements Product{
    @Override
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

// 抽象工厂
public interface AbstractFactory {
    Product newProduct();
}

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory{
    @Override
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品1...");
        return new ConcreteProduct2();
    }
}

编写测试类进行测试工厂方法模式：

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        Product product1 = factory1.newProduct();
        product1.show();

        AbstractFactory factory2 = new ConcreteFactory2();
        Product product2 = factory2.newProduct();
        product2.show();
    }
}

输出结果如下所示：

具体工厂1生成-->具体产品1...
具体产品1显示...
具体工厂2生成-->具体产品1...
具体产品2显示...

注意：工厂方法模式只考虑生产单一产品的情况。

抽象工厂模式

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

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

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

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

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

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

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

模式的结构

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

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

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

模式的实现

抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。

(1) 抽象产品

public interface Product1 {
    void show();
}

public interface Product2 {
    void show();
}

(2) 具体的产品

public class ConcreteProduct11 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品11显示...");
    }
}

public class ConcreteProduct12 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品12显示...");
    }
}

public class ConcreteProduct21 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品21显示...");
    }
}

public class ConcreteProduct22 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品22显示...");
    }
}

(3) 定义抽象工厂

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

(4) 抽象工厂的实现类，也就是具体的工厂类

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

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂 1 生成-->具体产品 ConcreteProduct21...");
        return new ConcreteProduct21();
    }
}

public class ConcreteFactory2 implements AbstractFactory{
    @Override
    public Product1 newProduct1() {
        System.out.println("具体工厂 2 生成-->具体产品 ConcreteProduct11...");
        return new ConcreteProduct11();
    }

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂 2 生成-->具体产品 ConcreteProduct22...");
        return new ConcreteProduct22();
    }
}

(5) 测试的代码如下：

public class Client {
    public static void main(String[] args){
        AbstractFactory factory1 = new ConcreteFactory1();
        Product1 product1 = factory1.newProduct1();
        product1.show();

        AbstractFactory factory2 = new ConcreteFactory2();
        Product2 product4 = factory2.newProduct2();
        product4.show();
    }
}

输出结果如下：

具体工厂 1 生成-->具体产品 ConcreteProduct11...
具体产品11显示...
具体工厂 2 生成-->具体产品 ConcreteProduct22...
具体产品22显示...

和抽象方法模式区别在于抽象工厂生成的产品不再单一。当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。