抽象工厂模式

一、定义

1. 产品族和产品等级的概念

（1）产品族：同一工厂下的不同产品；
（2）产品等级：不同工厂下的同一产品；

2. 定义

（1）为创建一组相关或相互依赖的对象提供一个接口，无须指定它们的具体类；
（2）抽象工厂模式是工厂方法模式的进一步抽象，抽象工厂方法模式针对的是一族产品，如果产品族中只有一种产品，则抽象工厂模式退化为工厂方法模式；

3. 抽象工厂模式涉及到的角色

（1）抽象工厂角色：抽象工厂模式的核心，与应用系统无关，任何创建对象的工厂必须实现这个接口；
（2）具体工厂角色：实现了抽象工厂接口，含有选择合适产品对象的逻辑，受到应用程序调用以创建产品对象；
（3）抽象产品角色：定义产品的共性；
（4）具体产品角色：实现抽象产品角色所声明的接口；

二、类图

三、代码实现

（一）产品角色

1、抽象产品角色A

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA
 * @description: 抽象工厂模式的抽象产品角色
 * @date 2023/11/2121:44
 */
public interface ProductA {

    void method();
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2、具体产品角色A1

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA1
 * @description: 具体产品角色A1
 * @date 2023/11/2121:49
 */
public class ProductA1 implements ProductA{
    @Override
    public void method() {
        System.out.println("这是产品A1");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、具体产品角色A2

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA1
 * @description: 具体产品角色A2
 * @date 2023/11/2121:49
 */
public class ProductA2 implements ProductA{
    @Override
    public void method() {
        System.out.println("这是产品A2");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4、抽象产品角色B

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA
 * @description: 抽象工厂模式的抽象产品角色
 * @date 2023/11/2121:44
 */
public interface ProductB {

    void method();
}

1
2
3
4
5
6
7
8
9
10
11
12
13

5、具体产品角色B1

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA1
 * @description: 具体产品角色B1
 * @date 2023/11/2121:49
 */
public class ProductB1 implements ProductB{
    @Override
    public void method() {
        System.out.println("这是产品B1");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、具体产品角色B2

package com.xiaobai.design_pattern.abstractfactory.productrole;

/**
 * @author wangtw
 * @ClassName ProductA1
 * @description: 具体产品角色B2
 * @date 2023/11/2121:49
 */
public class ProductB2 implements ProductB{
    @Override
    public void method() {
        System.out.println("这是产品B2");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（二）工厂角色

1、抽象工厂角色

package com.xiaobai.design_pattern.abstractfactory.createrole;

import com.xiaobai.design_pattern.abstractfactory.productrole.ProductA;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductB;

/**
 * @author wangtw
 * @ClassName AbstractFactory
 * @description: 抽象工厂模式的抽象工厂角色
 * @date 2023/11/2121:43
 */
public interface AbstractFactory {

    /**
     * 创建产品A
     * @return
     */
    ProductA factoryA();

    /**
     * 创建产品B
     * @return
     */
    ProductB factoryB();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2、具体工厂角色1

package com.xiaobai.design_pattern.abstractfactory.createrole;

import com.xiaobai.design_pattern.abstractfactory.productrole.ProductA;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductA1;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductB;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductB1;

/**
 * @author wangtw
 * @ClassName ConcreteFactory1
 * @description: 具体工厂1
 * @date 2023/11/2121:55
 */
public class ConcreteFactory1 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        return new ProductA1();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB1();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3、具体工厂角色2

package com.xiaobai.design_pattern.abstractfactory.createrole;

import com.xiaobai.design_pattern.abstractfactory.productrole.*;

/**
 * @author wangtw
 * @ClassName ConcreteFactory1
 * @description: 具体工厂2
 * @date 2023/11/2121:55
 */
public class ConcreteFactory2 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        return new ProductA2();
    }

    @Override
    public ProductB factoryB() {
        return new ProductB2();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（三）测试类

package com.xiaobai.design_pattern.abstractfactory;

import com.xiaobai.design_pattern.abstractfactory.createrole.AbstractFactory;
import com.xiaobai.design_pattern.abstractfactory.createrole.ConcreteFactory1;
import com.xiaobai.design_pattern.abstractfactory.createrole.ConcreteFactory2;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductA;
import com.xiaobai.design_pattern.abstractfactory.productrole.ProductB;
import org.junit.jupiter.api.Test;

/**
 * @author wangtw
 * @ClassName AbstractFactoryTest
 * @description: 抽象工厂模式测试类
 * @date 2023/11/2121:59
 */
public class AbstractFactoryTest {

    @Test
    public void test() {

        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.factoryA();
        ProductB productB1 = factory1.factoryB();
        productA1.method();
        productB1.method();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.factoryA();
        ProductB productB2 = factory2.factoryB();
        productA2.method();
        productB2.method();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

输出：

这是产品A1
这是产品B1
这是产品A2
这是产品B2

四、总结

1、抽象工厂模式优点
（1）不同工厂的各种产品可能具有不同的相互依赖关系，这些依赖关系对工厂的使用者不可见；
（2）如果要针对同一产品族建立新的生产线，只需要实现产品族的所有产品接口并新建新的工厂类即可；

2、抽象工厂模式的缺点
产品族扩展困难，如果需要在产品族中增加一个新产品类型，则需要修改多个接口，并且会影响已有的工厂类
参考：

韩敬海 设计模式（Java版）
Bee.F 抽象工厂模式（通俗易懂）