【创造型模式】抽象工厂方法模式

news2025/7/18 11:38:50

文章目录

抽象工厂方法模式
- 产品族与产品等级结构
- 抽象工厂方法模式的角色和职责
- 抽象工厂方法模式的实现
- 抽象工厂方法模式的优缺点
- 适用场景

抽象工厂方法模式

在这里插入图片描述
工厂方法模式引入了“工厂等级结构”，解决了简单工厂方法过分依赖单一工厂的问题。但是工厂方法模式存在的一个问题是，针对每一种产品，都需要设计一种工厂，比如对于“苹果”和“山东苹果”，我们就需要分别设计一个“苹果工厂”和“山东苹果工厂”。

工厂方法模式现有的问题在于：

但添加一个新产品的时候（比如葡萄），虽然遵循开闭原则，不修改现有的代码，但是需要添加大量的类（比如辽宁葡萄、河北葡萄、山东葡萄），而且需要添加相对应的工厂，增加了系统开销和维护成本。
如果同一个“地域”有多种产品，比如“辽宁葡萄”、“辽宁樱桃”、“辽宁苹果”，那么需要分别创建具体的工厂，而不能通过一个工厂来生产所有的产品。虽然该方法满足开闭原则，但是代码将会变得非常复杂，不够好。

抽象工厂方法模式的引入进一步优化了工厂方法模式。具体来说，抽象工厂方法模式引入了“产品等级结构”和“产品族”这两个概念。

产品族与产品等级结构

此处借用《Easy 搞定 Golang 设计模式》当中的原图：

产品族：具有同一个地区、同一个厂商、同一个开发包、同一个组织模块等隶属关系，但是具备不同的特点或功能，这样的产品构成的集合，就是一个产品族。比如产自同一个产地的各种水果，就构成一个产品族。
产品等级结构：具有相同特点或功能，但是隶属的组织模块不同，这样的产品结构，称为一个产品等级。不同产地的同一种水果就是同一个产品等级。

“抽象工厂方法模式”针对“产品族”进行产品生产。

抽象工厂方法模式的角色和职责

抽象工厂角色：声明了一组用于创建一组产品的方法，每一个方法对应一种产品。
具体工厂角色：实现了在抽象工厂中声明的创建产品的方法，生成一组具体的产品，这些产品构成一个产品族，每一个产品都位于某个产品结构当中。
抽象产品角色：为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
具体产品角色：定义具体工厂生产的具体产品对象，实现抽象产品接口声明的业务方法。

抽象工厂方法模式的实现

package main

import "fmt"

// ---------- 抽象层 ----------
type AbstractApple interface {
	ShowApple()
}

type AbstractBanana interface {
	ShowBanana()
}

type AbstractPear interface {
	ShowPear()
}

// 抽象工厂: 定义了工厂可以生产哪些抽象产品
type AbstractFactory interface {
	CreateApple() AbstractApple
	CreateBanana() AbstractBanana
	CreatePear() AbstractPear
}

// ---------- 实现层 ----------
type LiaoningApple struct{}

func (la *LiaoningApple) ShowApple() {
	fmt.Println("Liaoning Apple")
}

type LiaoningBanana struct{}

func (lb *LiaoningBanana) ShowBanana() {
	fmt.Println("Liaoning Banana")
}

type LiaoningPear struct{}

func (lp *LiaoningPear) ShowPear() {
	fmt.Println("Liaoning Pear")
}

type LiaoningFactory struct{}

func (fa *LiaoningFactory) CreateApple() AbstractApple {
	return &LiaoningApple{}
}

func (fa *LiaoningFactory) CreateBanana() AbstractBanana {
	return &LiaoningBanana{}
}

func (fa *LiaoningFactory) CreatePear() AbstractPear {
	return &LiaoningPear{}
}

type JiangsuApple struct{}

func (ja *JiangsuApple) ShowApple() {
	fmt.Println("Jiangsu Apple")
}

type JiangsuBanana struct{}

func (jb *JiangsuBanana) ShowBanana() {
	fmt.Println("Jiangsu Banana")
}

type JiangsuPear struct{}

func (jp *JiangsuPear) ShowPear() {
	fmt.Println("Jiangsu Pear")
}

type JiangsuFactory struct{}

func (fa *JiangsuFactory) CreateApple() AbstractApple {
	return &JiangsuApple{}
}

func (fa *JiangsuFactory) CreateBanana() AbstractBanana {
	return &JiangsuBanana{}
}

func (fa *JiangsuFactory) CreatePear() AbstractPear {
	return &JiangsuPear{}
}

type BeijingApple struct{}

func (ba *BeijingApple) ShowApple() {
	fmt.Println("Beijing Apple")
}

type BeijingBanana struct{}

func (bb *BeijingBanana) ShowBanana() {
	fmt.Println("Beijing Banana")
}

type BeijingPear struct{}

func (pbp *BeijingPear) ShowPear() {
	fmt.Println("Beijing Pear")
}

type BeijingFactory struct{}

func (fa *BeijingFactory) CreateApple() AbstractApple {
	return &BeijingApple{}
}

func (fa *BeijingFactory) CreateBanana() AbstractBanana {
	return &BeijingBanana{}
}

func (fa *BeijingFactory) CreatePear() AbstractPear {
	return &BeijingPear{}
}

func main() {
	// 创建辽宁的苹果, 香蕉, 梨等对象
	var liaoningFac AbstractFactory
	liaoningFac = &LiaoningFactory{}

	var liaoningApple AbstractApple
	liaoningApple = liaoningFac.CreateApple()
	liaoningApple.ShowApple()

	var liaoningBanana AbstractBanana
	liaoningBanana = liaoningFac.CreateBanana()
	liaoningBanana.ShowBanana()

	var liaoningPear AbstractPear
	liaoningPear = liaoningFac.CreatePear()
	liaoningPear.ShowPear()

	// 创建其他产区的水果
	jiangsuFac := &JiangsuFactory{}

	jiangsuApple := jiangsuFac.CreateApple()
	jiangsuApple.ShowApple()

	jiangsuBanana := jiangsuFac.CreateBanana()
	jiangsuBanana.ShowBanana()

	jiangsuPear := jiangsuFac.CreatePear()
	jiangsuPear.ShowPear()

	beijingFac := &BeijingFactory{}

	beijingApple := beijingFac.CreateApple()
	beijingApple.ShowApple()

	beijingBanana := beijingFac.CreateBanana()
	beijingBanana.ShowBanana()

	beijingPear := beijingFac.CreatePear()
	beijingPear.ShowPear()
}