工厂模式
工厂模式是一种创建型设计模式，核心思路是封装对象的创建过程——让客户端代码不必硬编码具体的类，而是通过一个统一的接口来获取实例。在 Go 语言里，这种模式通常借助接口和结构体组合来实现。
具体来说，工厂模式会先定义一个工厂接口，里面放一个创建产品的方法。然后，针对每种产品类型，实现一个具体的工厂类，负责生成该产品的实例。客户端只需要跟工厂接口打交道，至于对象是怎么被 new 出来的、中间经历了什么，完全不用操心。
根据封装程度的不同，工厂模式可以细分为三种常见变体：
- 简单工厂模式：用一个工厂类包揽所有产品的创建。客户端通过参数告诉工厂想要什么类型，工厂直接返回对应的实例。优点是简单直观，缺点是扩展性差——每新增一种产品，都得修改工厂类的代码。
- 工厂方法模式：把具体产品的创建延迟到子类。每个产品都有自己专属的工厂类，客户端调用哪个工厂，就得到哪个产品。这样产品与工厂解耦了，扩展起来很方便，但代价是类的数量会明显增加。
- 抽象工厂模式：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。每个工厂都能生产一个“产品族”，保证产品之间的兼容性。适合构建复杂的对象群，比如不同操作系统下的 UI 组件。不过，如果新增一种产品类型，可能得修改所有工厂实现。
场景
- 数据库驱动：连接不同类型的数据库时，用工厂模式根据配置或用户选择返回对应的连接实例。
- 日志记录器：应用可能使用 logrus、zap 等不同日志库，通过工厂模式在启动时确定具体实现，之后统一用日志接口记录。
- 网络请求客户端：与不同网络服务通信时，工厂可以返回 HTTP 客户端、gRPC 客户端等实例。
- 加密算法：需要 AES、RSA 等不同加密算法时，工厂根据需求创建对应的加密器实例。
- 插件系统：支持插件的应用，利用工厂模式动态加载并实例化插件，根据类型或其他条件返回不同的插件对象。
优点
- 解耦合：对象的创建逻辑与使用逻辑分离，修改创建方式只影响工厂，不波及客户端代码。
- 灵活性：可以在运行时根据条件动态选择创建哪种对象实例。
- 代码复用：统一管理创建逻辑，避免重复代码。
- 易于扩展：新增产品类时，只需扩展工厂方法，客户端无需改动。
缺点
- 类爆炸：产品类型一多，工厂类数量也会膨胀，管理起来可能变得头疼。
- 违反开闭原则：如果每次新增产品都要修改工厂方法（比如简单工厂），那就违背了“对扩展开放，对修改关闭”的原则。
- 过度设计：在简单场景硬套工厂模式，反而增加了不必要的复杂度。
简单工厂模式示例
package main
import "fmt"
// 定义接口：水果
type Fruit interface {
Eat() string // 定义吃水果的方法
}
// 定义具体产品类：苹果
type Apple struct{}
// 实现苹果的 Eat 方法
func (a *Apple) Eat() string {
return "吃苹果"
}
// 定义具体产品类：香蕉
type Banana struct{}
// 实现香蕉的 Eat 方法
func (b *Banana) Eat() string {
return "吃香蕉"
}
// 定义水果工厂类
type FruitFactory struct{}
// 创建水果的方法
func (ff *FruitFactory) CreateFruit(fruitType string) Fruit {
switch fruitType {
case "apple":
return &Apple{} // 返回苹果实例
case "banana":
return &Banana{} // 返回香蕉实例
default:
panic("不支持的水果类型")
}
}
func main() {
// 创建水果工厂
factory := &FruitFactory{}
// 使用工厂创建苹果对象
apple := factory.CreateFruit("apple")
fmt.Println(apple.Eat()) // 输出：吃苹果
// 使用工厂创建香蕉对象
banana := factory.CreateFruit("banana")
fmt.Println(banana.Eat()) // 输出：吃香蕉
}
- 输出结果
吃苹果 吃香蕉
工厂方法模式示例
package main
import "fmt"
// 定义接口：运算器
type Operator interface {
Operate(int, int) int // 定义运算方法
}
// 定义具体产品类：加法运算器
type AddOperator struct{}
// 实现加法运算器的 Operate 方法
func (a *AddOperator) Operate(num1, num2 int) int {
return num1 + num2
}
// 定义具体产品类：减法运算器
type SubtractOperator struct{}
// 实现减法运算器的 Operate 方法
func (s *SubtractOperator) Operate(num1, num2 int) int {
return num1 - num2
}
// 定义工厂接口
type OperatorFactory interface {
Create() Operator // 创建运算器的方法
}
// 加法运算器工厂
type AddFactory struct{}
// 实现加法运算器工厂的 Create 方法
func (af *AddFactory) Create() Operator {
return &AddOperator{}
}
// 减法运算器工厂
type SubtractFactory struct{}
// 实现减法运算器工厂的 Create 方法
func (sf *SubtractFactory) Create() Operator {
return &SubtractOperator{}
}
func main() {
// 创建加法运算器工厂
addFactory := &AddFactory{}
// 使用加法运算器工厂创建加法运算器
add := addFactory.Create()
// 调用加法运算器的 Operate 方法
fmt.Println("3 + 2 =", add.Operate(3, 2)) // 输出：3 + 2 = 5
// 创建减法运算器工厂
subtractFactory := &SubtractFactory{}
// 使用减法运算器工厂创建减法运算器
subtract := subtractFactory.Create()
// 调用减法运算器的 Operate 方法
fmt.Println("3 - 2 =", subtract.Operate(3, 2)) // 输出：3 - 2 = 1
}
- 输出结果
3 + 2 = 5 3 - 2 = 1
抽象工厂模式示例
package main
import "fmt"
// 定义接口：形状
type Shape interface {
Draw() string // 绘制形状的方法
}
// 定义具体产品类：圆形
type Circle struct{}
// 实现圆形的 Draw 方法
func (c *Circle) Draw() string {
return "画一个圆形"
}
// 定义具体产品类：矩形
type Rectangle struct{}
// 实现矩形的 Draw 方法
func (r *Rectangle) Draw() string {
return "画一个矩形"
}
// 定义接口：颜色
type Color interface {
Fill() string // 填充颜色的方法
}
// 定义具体产品类：红色
type Red struct{}
// 实现红色的 Fill 方法
func (r *Red) Fill() string {
return "填充红色"
}
// 定义具体产品类：蓝色
type Blue struct{}
// 实现蓝色的 Fill 方法
func (b *Blue) Fill() string {
return "填充蓝色"
}
// 定义抽象工厂接口
type AbstractFactory interface {
CreateShape() Shape // 创建形状的方法
CreateColor() Color // 创建颜色的方法
}
// 具体工厂类：形状为圆形，颜色为红色的工厂
type RedCircleFactory struct{}
// 实现创建形状的方法
func (rcf *RedCircleFactory) CreateShape() Shape {
return &Circle{}
}
// 实现创建颜色的方法
func (rcf *RedCircleFactory) CreateColor() Color {
return &Red{}
}
// 具体工厂类：形状为矩形，颜色为蓝色的工厂
type BlueRectangleFactory struct{}
// 实现创建形状的方法
func (brf *BlueRectangleFactory) CreateShape() Shape {
return &Rectangle{}
}
// 实现创建颜色的方法
func (brf *BlueRectangleFactory) CreateColor() Color {
return &Blue{}
}
func main() {
// 创建形状为圆形，颜色为红色的工厂
redCircleFactory := &RedCircleFactory{}
// 使用工厂创建形状
shape1 := redCircleFactory.CreateShape()
// 使用工厂创建颜色
color1 := redCircleFactory.CreateColor()
// 调用形状和颜色的方法
fmt.Println(shape1.Draw()) // 输出：画一个圆形
fmt.Println(color1.Fill()) // 输出：填充红色
// 创建形状为矩形，颜色为蓝色的工厂
blueRectangleFactory := &BlueRectangleFactory{}
// 使用工厂创建形状
shape2 := blueRectangleFactory.CreateShape()
// 使用工厂创建颜色
color2 := blueRectangleFactory.CreateColor()
// 调用形状和颜色的方法
fmt.Println(shape2.Draw()) // 输出：画一个矩形
fmt.Println(color2.Fill()) // 输出：填充蓝色
}
- 输出结果
画一个圆形 填充红色 画一个矩形 填充蓝色
工厂模式 - 线程安全
多线程环境下使用工厂模式，得注意并发安全。下面列出几种常见的做法：
- 使用互斥锁（Mutex）：在工厂函数中用互斥锁保护共享资源，保证同一时间只有一个 goroutine 能执行创建逻辑。
type Factory struct {
mu sync.Mutex
}
func (f *Factory) CreateObject() Object {
f.mu.Lock()
defer f.mu.Unlock()
// 创建对象的逻辑
}
- 使用读写锁（RWMutex）：如果创建操作不涉及修改共享状态，可以用读写锁允许多个 goroutine 同时读，但写操作互斥。
type Factory struct {
mu sync.RWMutex
}
func (f *Factory) CreateObject() Object {
f.mu.Lock()
defer f.mu.Unlock()
// 创建对象的逻辑
}
- 使用通道（Channel）：利用无缓冲通道的阻塞特性，让工厂函数只有一个 goroutine 能进入。
type Factory struct {
ch chan struct{}
}
func NewFactory() *Factory {
return &Factory{ch: make(chan struct{}, 1)}
}
func (f *Factory) CreateObject() Object {
f.ch <- struct{}{} // 发送信号，阻塞其他goroutine
defer func() { <-f.ch }() // 接收信号，释放通道
// 创建对象的逻辑
}
- 使用 sync.Once：如果只需要在第一次调用时初始化对象，且不需要参数，sync.Once 能确保初始化逻辑只执行一次。
type Factory struct {
once sync.Once
obj Object
}
func (f *Factory) CreateObject() Object {
f.once.Do(func() {
// 初始化对象的逻辑
f.obj = initializeObject()
})
return f.obj
}
原型模式
原型模式（Prototype Pattern）想解决的问题很简单：与其每次都 new 一个对象，不如复制现成的。通过复制原型对象来创建新实例，而不是走常规的实例化路径。在 Go 里，通常用深拷贝（deep copy）或浅拷贝（shallow copy）来实现复制。
场景
- 对象初始化复杂：初始化过程耗时或繁琐时，复制已有对象能省掉重复的初始化步骤，提升性能。
- 动态创建对象：运行时根据条件动态创建实例，原型模式可以灵活地增加新原型并复制。
- 创建过程无法预知：当对象的创建过程需要根据上下文调整时，通过复制现有对象可以动态修改属性或行为。
- 保护初始化状态：某些对象初始化后需要保持特定状态，但又要不断创建新实例，原型模式可以复制而不影响原始对象的状态。
优点
- 减少对象创建开销。
- 简化创建过程。
- 支持动态增加新对象类型。
缺点
- 复制可能复杂：如果对象包含引用或非导出字段，需要额外处理。
- 复制过程本身可能影响性能。
浅拷贝示例
package main
import "fmt"
// 定义接口：原型
type Prototype interface {
Clone() Prototype // 克隆方法
}
// 具体产品类：狗
type Dog struct {
Name string
Age int
}
// 实现原型的 Clone 方法
func (d *Dog) Clone() Prototype {
return &Dog{Name: d.Name, Age: d.Age}
}
func main() {
// 创建原型对象
originalDog := &Dog{Name: "旺财", Age: 3}
// 克隆原型对象
clonedDog := originalDog.Clone().(*Dog)
// 修改克隆对象的属性
clonedDog.Name = "小白"
clonedDog.Age = 2
// 输出原型对象信息
fmt.Println("原型对象：", originalDog.Name, originalDog.Age)
// 输出克隆对象信息
fmt.Println("克隆对象：", clonedDog.Name, clonedDog.Age)
}
- 输出结果
型对象： 旺财 3 克隆对象： 小白 2
深拷贝示例
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
// Address 是地址结构体
type Address struct {
Street string
City string
ZipCode string
Country string
Building string
}
// Person 是人员结构体
type Person struct {
Name string
Age int
Address *Address
}
// CloneAddress 深拷贝地址结构体
func CloneAddress(addr *Address) *Address {
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
_ = enc.Encode(addr)
dec := gob.NewDecoder(&buf)
clone := new(Address)
_ = dec.Decode(clone)
return clone
}
// ClonePerson 深拷贝人员结构体
func (p *Person) Clone() *Person {
return &Person{
Name: p.Name,
Age: p.Age,
Address: CloneAddress(p.Address),
}
}
func main() {
// 创建原型对象
original := &Person{
Name: "Alice",
Age: 30,
Address: &Address{
Street: "123 Main St",
City: "Anytown",
ZipCode: "12345",
Country: "USA",
Building: "Apt 101",
},
}
// 创建原型对象的深拷贝副本
clone := original.Clone()
// 修改原型对象的地址信息
original.Address.City = "New City"
original.Address.Building = "Apt 202"
// 打印原型对象和副本对象的地址信息
fmt.Println("Original Address:", original.Address)
fmt.Println("Cloned Address:", clone.Address)
}
- 输出结果
Original Address: &{123 Main St New City 12345 USA Apt 202}
Cloned Address: &{123 Main St Anytown 12345 USA Apt 101}
建造者模式
建造者模式（Builder Pattern）把复杂对象的构建过程拆分成多个步骤，然后用同一个构建流程产出不同的表示。核心是“将构建过程与表示分离”。
模式中涉及几个角色：
- 产品（Product）：被构建的复杂对象，包含多个部件。
- 建造者（Builder）：定义构建产品的抽象接口，包含构建各个部件的方法。
- 具体建造者（Concrete Builder）：实现建造者接口，负责具体产品的构建过程。通常有多个，对应不同表示。
- 指挥者（Director）：使用建造者对象来构建产品，屏蔽客户端与构建过程的直接交互。
场景
- 复杂对象的构建：构建过程包含多个部件，且顺序或逻辑可能变化时，建造者模式能封装变化，提高可维护性。
- 创建多个相似但不同表示的对象：比如多种口味的冰淇淋，构建步骤相似但原料不同，建造者模式可以复用流程。
- 根据不同的构建过程创建不同的表示：比如根据用户选项构建不同配置的计算机。
- 隐藏产品构建细节：客户端只跟指挥者交互，不需要知道具体构建步骤。
优点
- 封装复杂构建过程。
- 复用构建流程，避免代码重复。
- 灵活性和可扩展性：通过更换具体建造者或指挥者，可以轻松改变产品表示。
- 隐藏构建细节，降低客户端与产品的耦合。
缺点
- 增加系统复杂度：引入新的类和接口。
- 需要额外开发工作。
- 不适用于简单对象。
- 可能增加对象创建开销（尤其大量对象时）。
示例
package main
import "fmt"
// 产品：汽车
type Car struct {
Brand string // 汽车品牌
Engine string // 汽车发动机型号
Color string // 汽车颜色
}
// 建造者接口
type Builder interface {
SetBrand() // 设置汽车品牌
SetEngine() // 设置汽车发动机型号
SetColor() // 设置汽车颜色
GetResult() *Car // 获取构建结果
}
// 具体建造者：小汽车建造者
type SmallCarBuilder struct {
car *Car
}
// 实现建造者接口
func (s *SmallCarBuilder) SetBrand() {
s.car.Brand = "小汽车品牌"
}
func (s *SmallCarBuilder) SetEngine() {
s.car.Engine = "1.0L 发动机"
}
func (s *SmallCarBuilder) SetColor() {
s.car.Color = "红色"
}
func (s *SmallCarBuilder) GetResult() *Car {
return s.car
}
// 指挥者：汽车厂
type CarFactory struct {
builder Builder // 使用的建造者
}
// 构造函数
func NewCarFactory(builder Builder) *CarFactory {
return &CarFactory{builder: builder}
}
// 构建汽车的方法
func (c *CarFactory) Construct() *Car {
// 初始化汽车对象
c.builder.GetResult()
c.builder.SetBrand() // 设置汽车品牌
c.builder.SetEngine() // 设置汽车发动机型号
c.builder.SetColor() // 设置汽车颜色
return c.builder.GetResult() // 返回构建结果
}
func main() {
// 创建小汽车建造者
smallCarBuilder := &SmallCarBuilder{car: &Car{}}
// 创建汽车厂并指定建造者
carFactory := NewCarFactory(smallCarBuilder)
// 构建汽车
car := carFactory.Construct()
// 输出汽车配置信息
fmt.Println("汽车配置：")
fmt.Println("品牌:", car.Brand)
fmt.Println("发动机:", car.Engine)
fmt.Println("颜色:", car.Color)
}
- 输出结果
汽车配置： 品牌: 小汽车品牌 发动机: 1.0L 发动机 颜色: 红色
总结
本文梳理了 Go 语言中三种常见的创建型设计模式——工厂模式、原型模式和建造者模式，并给出了具体的代码示例和线程安全处理方式。理解这些模式的核心思想，可以帮助我们在实际项目中更灵活地组织对象创建逻辑，写出更易维护、更具扩展性的代码。
