六、抽象工厂模式

一、什么是抽象工厂模式

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

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

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

二、抽象工厂模式的实现

假设有1、2两种产品，而每种产品都有1、2两种不同的类型，那么就会组合出1_1、1_2、2_1、2_2四种不同的产品。每个工厂都可以生产产品1 和产品2，那么久需要四个工厂去生产不同的产品1和2 的组合，代码如下：
1、抽象产品

抽象产品1

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:05
 * @description 抽象产品1
 */
public interface AbstractProduct1 {
    void show();
}

抽象产品2

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:05
 * @description 抽象产品2
 */
public interface AbstractProduct2 {
    void show();
}

2、具体产品（每个产品有两个不同型号）

产品1的型号1

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:07
 * @description 抽象产品1 的实现1
 */
public class ConcreteAbstractProduct1_1 implements AbstractProduct1 {
    @Override
    public void show() {
        System.out.println("产品1的1类型生成完毕...............");
    }
}

产品1的型号2

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:07
 * @description 抽象产品1 的实现2
 */
public class ConcreteAbstractProduct1_2 implements AbstractProduct1 {
    @Override
    public void show() {
        System.out.println("产品1的2类型生成完毕...............");
    }
}

产品2的型号1

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:07
 * @description 抽象产品2 的实现1
 */
public class ConcreteAbstractProduct2_1 implements AbstractProduct2 {
    @Override
    public void show() {
        System.out.println("产品2的1类型生成完毕...............");
    }
}

产品2的型号2

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:07
 * @description 抽象产品2 的实现2
 */
public class ConcreteAbstractProduct2_2 implements AbstractProduct2 {
    @Override
    public void show() {
        System.out.println("产品2的2类型生成完毕...............");
    }
}

3、抽象工厂

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:04
 * @description 抽象工厂
 *
 * 抽象工厂可以生成 抽象产品1 和 抽象产品2
 *
 */
public interface AbstractFactory {
    AbstractProduct1 createProduct1();
    AbstractProduct2 createProduct2();
}

4、具体工厂

具体工厂1，生产1_1、2_1 两种产品的套装

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:10
 * @description 抽象工厂类 的实现1
 *
 * 不同的實現 可以組裝不同的產品 这个工厂组装  产品1 的实现1   和产品2 的实现1
 */
public class ConereteFacotry1 implements AbstractFactory {
    @Override
    public AbstractProduct1 createProduct1() {
        System.out.println("开始生成产品1的类型1..........");
        return new ConcreteAbstractProduct1_1();
    }

    @Override
    public AbstractProduct2 createProduct2() {
        System.out.println("开始生成产品2的类型1..........");
        return new ConcreteAbstractProduct2_1();
    }
}

具体工厂2，生产1_2、2_1 两种产品的套装


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:10
 * @description 抽象工厂类 的实现2
 *
 * 不同的實現 可以組裝不同的產品 这个工厂组装  产品1 的实现2   和产品2 的实现1
 */
public class ConereteFacotry2 implements AbstractFactory {

    @Override
    public AbstractProduct1 createProduct1() {
        System.out.println("开始生成产品1的类型2..........");
        return new ConcreteAbstractProduct1_2();
    }

    @Override
    public AbstractProduct2 createProduct2() {
        System.out.println("开始生成产品2的类型1..........");
        return new ConcreteAbstractProduct2_1();
    }
}

具体工厂3，生产1_1、2_2 两种产品的套装

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:10
 * @description 抽象工厂类 的实现3
 *
 * 不同的實現 可以組裝不同的產品 这个工厂组装  产品1 的实现1   和产品2 的实现2
 */
public class ConereteFacotry3 implements AbstractFactory {
    @Override
    public AbstractProduct1 createProduct1() {
        System.out.println("开始生成产品1的类型1..........");
        return new ConcreteAbstractProduct1_1();
    }

    @Override
    public AbstractProduct2 createProduct2() {
        System.out.println("开始生成产品2的类型2..........");
        return new ConcreteAbstractProduct2_2();
    }
}

具体工厂4，生产1_2、2_2 两种产品的套装

/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 16:10
 * @description 抽象工厂类 的实现1
 *
 * 不同的實現 可以組裝不同的產品 这个工厂组装  产品1 的实现2   和产品2 的实现2
 */
public class ConereteFacotry4 implements AbstractFactory {
    @Override
    public AbstractProduct1 createProduct1() {
        System.out.println("开始生成产品1的类型2..........");
        return new ConcreteAbstractProduct1_2();
    }

    @Override
    public AbstractProduct2 createProduct2() {
        System.out.println("开始生成产品2的类型2..........");
        return new ConcreteAbstractProduct2_2();
    }
}

5、测试类


/**
 * @author FluffyCatkin
 * @version 1.0
 * @date 2020/1/2 0002 15:41
 * @description 抽象工厂模式
 *  抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
 *
 * 抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
 *
 * 使用抽象工厂模式一般要满足以下条件。系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
 * 系统一次只可能消费其中某一族产品，即同族的产品一起使用。
 *
 * 抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
 * 当增加一个新的产品族时不需要修改原代码，满足开闭原则。
 *
 * 其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
 * 模式的结构与实现：
 *      抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。
 * 模式的结构：
 *  抽象工厂模式的主要角色如下。
 *      抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
 *      具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
 *      抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
 *      具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。
 *
 */
public class Main {
    /**
     * 测试工厂1  创建产品1 的类型1   和产品2 的类型1 的组合
     */
    @Test
    public void abstractFactoryTest1(){
        AbstractFactory abstractFactory = new ConereteFacotry1();
        AbstractProduct1 abstractProduct1 = abstractFactory.createProduct1();
        AbstractProduct2 abstractProduct2 = abstractFactory.createProduct2();
        abstractProduct1.show();
        abstractProduct2.show();
    }
    /**
     * 测试工厂1  创建产品1 的类型2   和产品2 的类型1 的组合
     */
    @Test
    public void abstractFactoryTest2(){
        AbstractFactory abstractFactory = new ConereteFacotry2();
        AbstractProduct1 abstractProduct1 = abstractFactory.createProduct1();
        AbstractProduct2 abstractProduct2 = abstractFactory.createProduct2();
        abstractProduct1.show();
        abstractProduct2.show();
    }
    /**
     * 测试工厂1  创建产品1 的类型1   和产品2 的类型2 的组合
     */
    @Test
    public void abstractFactoryTest3(){
        AbstractFactory abstractFactory = new ConereteFacotry3();
        AbstractProduct1 abstractProduct1 = abstractFactory.createProduct1();
        AbstractProduct2 abstractProduct2 = abstractFactory.createProduct2();
        abstractProduct1.show();
        abstractProduct2.show();
    }
    /**
     * 测试工厂1  创建产品1 的类型2   和产品2 的类型2 的组合
     */
    @Test
    public void abstractFactoryTest4(){
        AbstractFactory abstractFactory = new ConereteFacotry4();
        AbstractProduct1 abstractProduct1 = abstractFactory.createProduct1();
        AbstractProduct2 abstractProduct2 = abstractFactory.createProduct2();
        abstractProduct1.show();
        abstractProduct2.show();
    }
}

运行结果依次如下：


开始生成产品1的类型1..........
开始生成产品2的类型1..........
产品1的1类型生成完毕...............
产品2的1类型生成完毕...............



Process finished with exit code 0


开始生成产品1的类型2..........
开始生成产品2的类型1..........
产品1的2类型生成完毕...............
产品2的1类型生成完毕...............



Process finished with exit code 0


开始生成产品1的类型1..........
开始生成产品2的类型2..........
产品1的1类型生成完毕...............
产品2的2类型生成完毕...............



Process finished with exit code 0


开始生成产品1的类型2..........
开始生成产品2的类型2..........
产品1的2类型生成完毕...............
产品2的2类型生成完毕...............



Process finished with exit code 0

三、应用场景

抽象工厂模式通常适用于以下场景：

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

四、优缺点分析

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

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

其缺点是：

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

代码地址：https://gitee.com/fluffycatkin/JavaDesignModel.git

原文出处：http://c.biancheng.net/view/1351.html