抽象工厂模式

发表于 更新于 分类于 ，

抽象工厂模式是GoF 23种经典创建型设计模式的核心成员，作为工厂方法模式的进阶版本，它专为解决多等级、多系列产品的创建问题而生。其核心价值在于为客户端提供一套创建“产品族”的统一接口，屏蔽具体产品的实现细节，实现对象创建与使用的解耦，在复杂系统设计中应用广泛。本文将从核心结构、多语言实现、优缺点、使用场景及总结五个维度，全面拆解抽象工厂模式，助力开发者快速掌握其设计思想与落地技巧。

一、核心结构与设计思想

抽象工厂模式在工厂方法模式的基础上，进一步强化了对“产品族”的管理能力，核心围绕4个角色构建，各角色职责清晰、协同工作，其设计核心是“分离产品族的抽象定义与具体实现”。

1.1 核心角色定义

  • 抽象工厂（Abstract Factory）：定义创建多等级产品的抽象接口，包含多个创建不同类型产品的方法，通常通过抽象类或接口实现，是整个模式的核心契约。

  • 具体工厂（Concrete Factory）：实现抽象工厂的所有抽象方法，负责创建某一特定产品族下的全部具体产品，确保同一工厂生产的产品具备兼容性和关联性。

  • 抽象产品（Abstract Product）：定义某一等级产品的通用规范，描述产品的核心行为与特性，抽象工厂模式中会存在多个不同等级的抽象产品（如“电视机”“空调”）。

  • 具体产品（Concrete Product）：实现对应抽象产品的接口，是抽象工厂模式的最终实例化对象，由特定具体工厂创建，与具体工厂形成“一对多”的关联关系。

1.2 核心概念辨析

理解抽象工厂模式的关键，是区分两个核心概念：

  • 产品族：由同一具体工厂生产、属于不同产品等级的一组关联产品（如海尔工厂生产的电视机+空调，同属海尔品牌，具备协同适配特性）。

  • 产品等级：同一类产品的不同实现（如所有品牌的电视机，均属于“电视机”这一产品等级）。

抽象工厂模式的核心目标，就是对产品族的创建进行标准化管理，让客户端无需关注产品的具体品牌和实现细节，仅通过抽象接口即可获取所需的一组关联产品。

二、多语言落地实现（统一场景：电器产品族）

为便于跨语言对比理解，本文以“电器生产”为统一场景：定义两个产品族（海尔、TCL），两个产品等级（电视机、空调），分别通过C#、Python、Golang、C++及纯C语言实现抽象工厂模式，贴合各语言的语法特性与最佳实践。

2.1 C# 实现（抽象类+继承，经典落地）

C#作为强类型面向对象语言，天然支持抽象类与接口，完美契合抽象工厂模式的经典设计，代码可读性高、类型安全，适合企业级系统开发。

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
using System;

// 抽象产品1：电视机（定义电视机的通用行为）
public abstract class TV
{
    public abstract void ShowInfo(); // 展示产品信息
}

// 抽象产品2：空调（定义空调的通用行为）
public abstract class AirConditioner
{
    public abstract void ShowInfo(); // 展示产品信息
}

// 具体产品1-1：海尔电视机（实现电视机抽象接口）
public class HaierTV : TV
{
    public override void ShowInfo() => Console.WriteLine("【海尔电视机】- 智能4K，节能护眼");
}

// 具体产品1-2：海尔空调（实现空调抽象接口）
public class HaierAirConditioner : AirConditioner
{
    public override void ShowInfo() => Console.WriteLine("【海尔空调】- 一级能效，静音节能");
}

// 具体产品2-1：TCL电视机（实现电视机抽象接口）
public class TCLTV : TV
{
    public override void ShowInfo() => Console.WriteLine("【TCL电视机】- 量子点屏幕，高刷清晰");
}

// 具体产品2-2：TCL空调（实现空调抽象接口）
public class TCLAirConditioner : AirConditioner
{
    public override void ShowInfo() => Console.WriteLine("【TCL空调】- 快速制冷，智能控温");
}

// 抽象工厂：电器工厂（定义产品族的创建接口）
public abstract class ElectricApplianceFactory
{
    public abstract TV CreateTV(); // 创建电视机
    public abstract AirConditioner CreateAirConditioner(); // 创建空调
}

// 具体工厂1：海尔工厂（生产海尔产品族）
public class HaierFactory : ElectricApplianceFactory
{
    public override TV CreateTV() => new HaierTV();
    public override AirConditioner CreateAirConditioner() => new HaierAirConditioner();
}

// 具体工厂2：TCL工厂（生产TCL产品族）
public class TCLFactory : ElectricApplianceFactory
{
    public override TV CreateTV() => new TCLTV();
    public override AirConditioner CreateAirConditioner() => new TCLAirConditioner();
}

// 客户端调用（面向抽象编程，屏蔽具体实现）
class Client
{
    static void Main(string[] args)
    {
        // 1. 使用海尔工厂，获取海尔产品族
        ElectricApplianceFactory haierFactory = new HaierFactory();
        haierFactory.CreateTV().ShowInfo();
        haierFactory.CreateAirConditioner().ShowInfo();

        // 2. 切换为TCL工厂，获取TCL产品族（无需修改其他代码）
        ElectricApplianceFactory tclFactory = new TCLFactory();
        tclFactory.CreateTV().ShowInfo();
        tclFactory.CreateAirConditioner().ShowInfo();
    }
}

2.2 Python 实现（abc模块+动态特性，简洁灵活）

Python无严格的抽象类语法，通过abc模块实现抽象接口，结合动态语言的灵活性，无需繁琐的类型声明，代码简洁易读，适合快速开发场景。

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
from abc import ABC, abstractmethod

# 抽象产品1：电视机
class TV(ABC):
    @abstractmethod
    def show_info(self):
        """抽象方法：展示产品信息"""
        pass

# 抽象产品2：空调
class AirConditioner(ABC):
    @abstractmethod
    def show_info(self):
        """抽象方法：展示产品信息"""
        pass

# 具体产品1-1：海尔电视机
class HaierTV(TV):
    def show_info(self):
        print("【海尔电视机】- 智能4K，节能护眼")

# 具体产品1-2：海尔空调
class HaierAirConditioner(AirConditioner):
    def show_info(self):
        print("【海尔空调】- 一级能效，静音节能")

# 具体产品2-1：TCL电视机
class TCLTV(TV):
    def show_info(self):
        print("【TCL电视机】- 量子点屏幕，高刷清晰")

# 具体产品2-2：TCL空调
class TCLAirConditioner(AirConditioner):
    def show_info(self):
        print("【TCL空调】- 快速制冷，智能控温")

# 抽象工厂：电器工厂
class ElectricApplianceFactory(ABC):
    @abstractmethod
    def create_tv(self):
        """抽象方法：创建电视机"""
        pass

    @abstractmethod
    def create_air_conditioner(self):
        """抽象方法：创建空调"""
        pass

# 具体工厂1：海尔工厂
class HaierFactory(ElectricApplianceFactory):
    def create_tv(self):
        return HaierTV()

    def create_air_conditioner(self):
        return HaierAirConditioner()

# 具体工厂2：TCL工厂
class TCLFactory(ElectricApplianceFactory):
    def create_tv(self):
        return TCLTV()

    def create_air_conditioner(self):
        return TCLAirConditioner()

# 客户端调用
if __name__ == "__main__":
    # 获取海尔产品族
    haier_factory = HaierFactory()
    haier_factory.create_tv().show_info()
    haier_factory.create_air_conditioner().show_info()

    # 切换为TCL产品族
    tcl_factory = TCLFactory()
    tcl_factory.create_tv().show_info()
    tcl_factory.create_air_conditioner().show_info()

2.3 Golang 实现（接口+结构体，面向接口编程）

Golang无类和继承特性，核心是“面向接口编程”，通过接口模拟抽象工厂与抽象产品，结构体实现接口方法，贴合Go语言的极简设计理念，代码高效、无冗余。

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package main

import "fmt"

// 抽象产品1：电视机接口（定义电视机的行为规范）
type TV interface {
  howInfo() // 展示产品信息
}

// 抽象产品2：空调接口（定义空调的行为规范）
type AirConditioner interface {
      nfo() // 展示产品信息
}

// 具体产品1-1：海尔电视机（实现TV接口）
type HaierTV struct{}

func (h *HaierTV) ShowInfo() {
  mt.Println("【海尔电视机】- 智能4K，节能护眼")
}

// 具体产品1-2：海尔空调（实现AirConditioner接口）
type HaierAirConditioner struct{}

func (h *HaierAirConditioner) ShowInfo() {
 fmt.Println("【海尔空调】- 一级能效，静音节能")
}

// 具体产品2-1：TCL电视机（实现TV接口）
type TCLTV struct{}

func (t *TCLTV) ShowInfo() {
 fmt.Println("【TCL电视机】- 量子点屏幕，高刷清晰")
}

// 具体产品2-2：TCL空调（实现AirConditioner接口）
type TCLAirConditioner struct{}

func (t *TCLAirConditioner) ShowInfo() {
 fmt.Println("【TCL空调】- 快速制冷，智能控温")
}

// 抽象工厂：电器工厂接口（定义产品族创建规范）
type ElectricApplianceFactory interface {
  reateTV() TV // 创建电视机
  reateAirConditioner() AirConditioner // 创建空调
}

// 具体工厂1：海尔工厂（实现电器工厂接口）
type HaierFactory struct{}

func (h *HaierFactory) CreateTV() TV {
 return &HaierTV{}
}

func (h *HaierFactory) CreateAirConditioner() AirConditioner {
  eturn &HaierAirConditioner{}
}

// 具体工厂2：TCL工厂（实现电器工厂接口）
type TCLFactory struct{}

func (t *TCLFactory) CreateTV() TV {
 return &TCLTV{}
}

func (t *TCLFactory) CreateAirConditioner() AirConditioner {
   turn &TCLAirConditioner{}
}

// 客户端调用（依赖接口，不依赖具体实现）
func main() {
    使用海尔工厂
   r haierFactory ElectricApplianceFactory = &HaierFactory{}
 haierFactory.CreateTV().ShowInfo()
  aierFactory.CreateAirConditioner().ShowInfo()

    切换为TCL工厂
     tclFactory ElectricApplianceFactory = &TCLFactory{}
    Factory.CreateTV().ShowInfo()
      ctory.CreateAirConditioner().ShowInfo()
}
  tclFa    tcl    var    //       h            va     //     re             r             C      C                           f  ShowI      S

2.4 C++ 实现（纯虚函数+继承，高性能落地）

C++通过纯虚函数定义抽象类（抽象工厂/抽象产品），子类继承并实现具体逻辑，需注意定义虚析构函数避免内存泄漏，适合高性能、底层开发场景，是抽象工厂模式的经典落地方式。

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <iostream>
using namespace std;

// 抽象产品1：电视机
class TV {
public:
    virtual void ShowInfo() = 0; // 纯虚函数，定义抽象接口
    virtual ~TV() = default; // 虚析构函数，避免内存泄漏
};

// 抽象产品2：空调
class AirConditioner {
public:
    virtual void ShowInfo() = 0; // 纯虚函数，定义抽象接口
    virtual ~AirConditioner() = default; // 虚析构函数
};

// 具体产品1-1：海尔电视机
class HaierTV : public TV {
public:
    void ShowInfo() override {
        cout << "【海尔电视机】- 智能4K，节能护眼" << endl;
    }
};

// 具体产品1-2：海尔空调
class HaierAirConditioner : public AirConditioner {
public:
    void ShowInfo() override {
        cout << "【海尔空调】- 一级能效，静音节能" << endl;
    }
};

// 具体产品2-1：TCL电视机
class TCLTV : public TV {
public:
    void ShowInfo() override {
        cout << "【TCL电视机】- 量子点屏幕，高刷清晰" << endl;
    }
};

// 具体产品2-2：TCL空调
class TCLAirConditioner : public AirConditioner {
public:
    void ShowInfo() override {
        cout << "【TCL空调】- 快速制冷，智能控温" << endl;
    }
};

// 抽象工厂：电器工厂
class ElectricApplianceFactory {
public:
    virtual TV* CreateTV() = 0; // 抽象创建方法
    virtual AirConditioner* CreateAirConditioner() = 0; // 抽象创建方法
    virtual ~ElectricApplianceFactory() = default; // 虚析构函数
};

// 具体工厂1：海尔工厂
class HaierFactory : public ElectricApplianceFactory {
public:
    TV* CreateTV() override {
        return new HaierTV();
    }
    AirConditioner* CreateAirConditioner() override {
        return new HaierAirConditioner();
    }
};

// 具体工厂2：TCL工厂
class TCLFactory : public ElectricApplianceFactory {
public:
    TV* CreateTV() override {
        return new TCLTV();
    }
    AirConditioner* CreateAirConditioner() override {
        return new TCLAirConditioner();
    }
};

// 客户端调用
int main() {
    // 1. 使用海尔工厂
    ElectricApplianceFactory* haierFactory = new HaierFactory();
    haierFactory->CreateTV()->ShowInfo();
    haierFactory->CreateAirConditioner()->ShowInfo();

    // 2. 切换为TCL工厂
    ElectricApplianceFactory* tclFactory = new TCLFactory();
    tclFactory->CreateTV()->ShowInfo();
    tclFactory->CreateAirConditioner()->ShowInfo();

    // 释放内存，避免泄漏
    delete haierFactory;
    delete tclFactory;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针，模拟面向对象）

纯C语言无面向对象特性，通过“结构体嵌套+函数指针”模拟抽象接口与继承，将产品行为和工厂创建逻辑封装为函数指针，实现类似多态的效果，适合底层嵌入式开发场景。

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <stdio.h>
#include <stdlib.h>

// 抽象产品1：电视机（结构体+函数指针模拟抽象接口）
typedef struct TV {
    void (*ShowInfo)(struct TV*); // 展示产品信息的函数指针
} TV;

// 抽象产品2：空调（结构体+函数指针模拟抽象接口）
typedef struct AirConditioner {
    void (*ShowInfo)(struct AirConditioner*); // 展示产品信息的函数指针
} AirConditioner;

// 具体产品1-1：海尔电视机（嵌套TV结构体，模拟继承）
typedef struct HaierTV {
    TV tv;
} HaierTV;

// 海尔电视机的具体实现
void HaierTV_ShowInfo(TV* tv) {
    printf("【海尔电视机】- 智能4K，节能护眼\n");
}

// 具体产品1-2：海尔空调（嵌套AirConditioner结构体，模拟继承）
typedef struct HaierAirConditioner {
    AirConditioner ac;
} HaierAirConditioner;

// 海尔空调的具体实现
void HaierAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【海尔空调】- 一级能效，静音节能\n");
}

// 具体产品2-1：TCL电视机（嵌套TV结构体，模拟继承）
typedef struct TCLTV {
    TV tv;
} TCLTV;

// TCL电视机的具体实现
void TCLTV_ShowInfo(TV* tv) {
    printf("【TCL电视机】- 量子点屏幕，高刷清晰\n");
}

// 具体产品2-2：TCL空调（嵌套AirConditioner结构体，模拟继承）
typedef struct TCLAirConditioner {
    AirConditioner ac;
} TCLAirConditioner;

// TCL空调的具体实现
void TCLAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【TCL空调】- 快速制冷，智能控温\n");
}

// 抽象工厂：电器工厂（结构体+函数指针模拟抽象接口）
typedef struct ElectricApplianceFactory {
    TV* (*CreateTV)(struct ElectricApplianceFactory*); // 创建电视机
    AirConditioner* (*CreateAirConditioner)(struct ElectricApplianceFactory*); // 创建空调
} ElectricApplianceFactory;

// 具体工厂1：海尔工厂（嵌套电器工厂结构体，模拟继承）
typedef struct HaierFactory {
    ElectricApplianceFactory factory;
} HaierFactory;

// 海尔工厂创建电视机
TV* HaierFactory_CreateTV(ElectricApplianceFactory* factory) {
    HaierTV* haierTV = (HaierTV*)malloc(sizeof(HaierTV));
    haierTV->tv.ShowInfo = HaierTV_ShowInfo; // 绑定函数指针
    return (TV*)haierTV;
}

// 海尔工厂创建空调
AirConditioner* HaierFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    HaierAirConditioner* haierAC = (HaierAirConditioner*)malloc(sizeof(HaierAirConditioner));
    haierAC->ac.ShowInfo = HaierAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)haierAC;
}

// 具体工厂2：TCL工厂（嵌套电器工厂结构体，模拟继承）
typedef struct TCLFactory {
    ElectricApplianceFactory factory;
} TCLFactory;

// TCL工厂创建电视机
TV* TCLFactory_CreateTV(ElectricApplianceFactory* factory) {
    TCLTV* tclTV = (TCLTV*)malloc(sizeof(TCLTV));
    tclTV->tv.ShowInfo = TCLTV_ShowInfo; // 绑定函数指针
    return (TV*)tclTV;
}

// TCL工厂创建空调
AirConditioner* TCLFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    TCLAirConditioner* tclAC = (TCLAirConditioner*)malloc(sizeof(TCLAirConditioner));
    tclAC->ac.ShowInfo = TCLAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)tclAC;
}

// 客户端调用
int main() {
    // 1. 初始化海尔工厂，获取海尔产品族
    HaierFactory haierFactory;
    haierFactory.factory.CreateTV = HaierFactory_CreateTV;
    haierFactory.factory.CreateAirConditioner = HaierFactory_CreateAirConditioner;
    
    TV* haierTV = haierFactory.factory.CreateTV((ElectricApplianceFactory*)&haierFactory);
    haierTV->ShowInfo(haierTV);
    AirConditioner* haierAC = haierFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&haierFactory);
    haierAC->ShowInfo(haierAC);

    // 2. 初始化TCL工厂，获取TCL产品族
    TCLFactory tclFactory;
    tclFactory.factory.CreateTV = TCLFactory_CreateTV;
    tclFactory.factory.CreateAirConditioner = TCLFactory_CreateAirConditioner;
    
    TV* tclTV = tclFactory.factory.CreateTV((ElectricApplianceFactory*)&tclFactory);
    tclTV->ShowInfo(tclTV);
    AirConditioner* tclAC = tclFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&tclFactory);
    tclAC->ShowInfo(tclAC);

    // 释放内存，避免泄漏
    free(haierTV);
    free(haierAC);
    free(tclTV);
    free(tclAC);
    return 0;
}

三、抽象工厂模式的优缺点

抽象工厂模式是为复杂产品族场景设计的，其优势与劣势均源于“产品族的标准化管理”，需结合实际场景权衡使用。

3.1 核心优点

  • 解耦创建与使用：客户端仅面向抽象接口编程，无需关注具体产品的创建逻辑、实现细节，降低代码耦合度，提升系统可维护性。

  • 统一管理产品族：同一具体工厂负责生产一组关联产品，确保产品间的兼容性，避免客户端因误用不同产品族的产品而出现问题。

  • 支持产品族扩展：新增产品族时，仅需新增具体工厂和对应具体产品，无需修改原有抽象工厂、已有工厂及客户端代码，完美契合开闭原则。

  • 切换产品族便捷：客户端切换产品族时，仅需替换具体工厂实例，无需修改其他业务逻辑，提升系统的灵活性和适配性。

3.2 主要缺点

  • 产品等级扩展困难：新增产品等级（如在电视机、空调外新增冰箱）时，需修改抽象工厂和所有具体工厂的接口，违反开闭原则，扩展成本高。

  • 系统复杂度提升：多产品族、多产品等级场景下，会产生大量的工厂类和产品类，增加代码量和维护成本，降低系统可读性。

  • 产品族约束严格：系统默认“一次仅消费一个产品族”，若需同时使用多个产品族的产品，需额外处理，灵活性受限。

四、使用场景

抽象工厂模式适合“多产品族、多产品等级，且产品族需统一管理”的场景，具体应用如下：

  • 跨环境/跨平台组件开发：如跨操作系统的UI组件（Windows/Linux/macOS下的按钮、输入框、弹窗），每个操作系统对应一个产品族，同一组件对应一个产品等级，通过抽象工厂统一创建，确保组件在不同环境下的兼容性。

  • 品牌化产品系列管理：如电器、汽车等品牌化产品，每个品牌对应一个产品族，每个产品类型（如电视机、空调）对应一个产品等级，通过抽象工厂实现品牌产品的标准化生产。

  • 数据源/框架切换场景：如数据库访问框架（SQL Server/MySQL/Oracle），每种数据库对应一个产品族，数据库连接、命令、适配器对应不同产品等级，切换数据源时仅需替换具体工厂。

  • 复杂产品关联场景：当系统中的产品存在强关联关系，需确保同一产品族的产品协同工作（如分布式系统中的服务注册、配置中心、日志组件），抽象工厂可统一管理这些关联产品的创建。

注意：若仅需创建单等级产品，优先使用工厂方法模式；若产品等级频繁变化，不建议使用抽象工厂模式；若产品族固定、产品等级稳定，抽象工厂模式是最优选择。

五、总结

抽象工厂模式的核心是“对产品族的抽象与封装”，它在工厂方法模式的基础上，进一步解决了多等级产品的创建与管理问题，其设计思想是“面向抽象编程，屏蔽具体实现”，最终实现系统的解耦与扩展。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度一致：

  • 面向对象语言（C#、Python、Golang、C++）：通过接口/抽象类定义规范，结合继承/结构体实现具体逻辑，利用多态特性实现产品族的灵活切换，贴合模式的经典设计。

  • 纯C语言：通过结构体嵌套+函数指针模拟面向对象的继承与多态，核心是封装行为与创建逻辑，满足底层开发的无面向对象特性限制的需求。

在实际开发中，选择抽象工厂模式的关键的是“判断系统是否存在稳定的产品族和产品等级”。其核心价值在于提升系统的可扩展性和可维护性，但需避免过度设计——若系统产品结构简单、无需扩展产品族，工厂方法模式或简单工厂模式更简洁高效。只有当系统需要管理多组关联产品、且产品族需灵活扩展时，抽象工厂模式才能发挥其最大价值。