Golang之设计模式(创建型)使用及说明

工厂模式

工厂模式是一种创建型设计模式，核心思路是封装对象的创建过程——让客户端代码不必硬编码具体的类，而是通过一个统一的接口来获取实例。在 Go 语言里，这种模式通常借助接口和结构体组合来实现。

具体来说，工厂模式会先定义一个工厂接口，里面放一个创建产品的方法。然后，针对每种产品类型，实现一个具体的工厂类，负责生成该产品的实例。客户端只需要跟工厂接口打交道，至于对象是怎么被 new 出来的、中间经历了什么，完全不用操心。

根据封装程度的不同，工厂模式可以细分为三种常见变体：

1. 简单工厂模式：用一个工厂类包揽所有产品的创建。客户端通过参数告诉工厂想要什么类型，工厂直接返回对应的实例。优点是简单直观，缺点是扩展性差——每新增一种产品，都得修改工厂类的代码。
2. 工厂方法模式：把具体产品的创建延迟到子类。每个产品都有自己专属的工厂类，客户端调用哪个工厂，就得到哪个产品。这样产品与工厂解耦了，扩展起来很方便，但代价是类的数量会明显增加。
3. 抽象工厂模式：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。每个工厂都能生产一个“产品族”，保证产品之间的兼容性。适合构建复杂的对象群，比如不同操作系统下的 UI 组件。不过，如果新增一种产品类型，可能得修改所有工厂实现。

场景

1. 数据库驱动：连接不同类型的数据库时，用工厂模式根据配置或用户选择返回对应的连接实例。
2. 日志记录器：应用可能使用 logrus、zap 等不同日志库，通过工厂模式在启动时确定具体实现，之后统一用日志接口记录。
3. 网络请求客户端：与不同网络服务通信时，工厂可以返回 HTTP 客户端、gRPC 客户端等实例。
4. 加密算法：需要 AES、RSA 等不同加密算法时，工厂根据需求创建对应的加密器实例。
5. 插件系统：支持插件的应用，利用工厂模式动态加载并实例化插件，根据类型或其他条件返回不同的插件对象。

优点

1. 解耦合：对象的创建逻辑与使用逻辑分离，修改创建方式只影响工厂，不波及客户端代码。
2. 灵活性：可以在运行时根据条件动态选择创建哪种对象实例。
3. 代码复用：统一管理创建逻辑，避免重复代码。
4. 易于扩展：新增产品类时，只需扩展工厂方法，客户端无需改动。

缺点

1. 类爆炸：产品类型一多，工厂类数量也会膨胀，管理起来可能变得头疼。
2. 违反开闭原则：如果每次新增产品都要修改工厂方法（比如简单工厂），那就违背了“对扩展开放，对修改关闭”的原则。
3. 过度设计：在简单场景硬套工厂模式，反而增加了不必要的复杂度。

简单工厂模式示例

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()) // 输出：填充蓝色
}

• 输出结果

画一个圆形
填充红色
画一个矩形
填充蓝色

工厂模式 - 线程安全

多线程环境下使用工厂模式，得注意并发安全。下面列出几种常见的做法：

1. 使用互斥锁（Mutex）：在工厂函数中用互斥锁保护共享资源，保证同一时间只有一个 goroutine 能执行创建逻辑。

type Factory struct {
    mu sync.Mutex
}

func (f *Factory) CreateObject() Object {
    f.mu.Lock()
    defer f.mu.Unlock()
    // 创建对象的逻辑
}

2. 使用读写锁（RWMutex）：如果创建操作不涉及修改共享状态，可以用读写锁允许多个 goroutine 同时读，但写操作互斥。

type Factory struct {
    mu sync.RWMutex
}

func (f *Factory) CreateObject() Object {
    f.mu.Lock()
    defer f.mu.Unlock()
    // 创建对象的逻辑
}

3. 使用通道（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 }() // 接收信号，释放通道
    // 创建对象的逻辑
}

4. 使用 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）来实现复制。

场景

1. 对象初始化复杂：初始化过程耗时或繁琐时，复制已有对象能省掉重复的初始化步骤，提升性能。
2. 动态创建对象：运行时根据条件动态创建实例，原型模式可以灵活地增加新原型并复制。
3. 创建过程无法预知：当对象的创建过程需要根据上下文调整时，通过复制现有对象可以动态修改属性或行为。
4. 保护初始化状态：某些对象初始化后需要保持特定状态，但又要不断创建新实例，原型模式可以复制而不影响原始对象的状态。

优点

1. 减少对象创建开销。
2. 简化创建过程。
3. 支持动态增加新对象类型。

缺点

1. 复制可能复杂：如果对象包含引用或非导出字段，需要额外处理。
2. 复制过程本身可能影响性能。

浅拷贝示例

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）：使用建造者对象来构建产品，屏蔽客户端与构建过程的直接交互。

场景

1. 复杂对象的构建：构建过程包含多个部件，且顺序或逻辑可能变化时，建造者模式能封装变化，提高可维护性。
2. 创建多个相似但不同表示的对象：比如多种口味的冰淇淋，构建步骤相似但原料不同，建造者模式可以复用流程。
3. 根据不同的构建过程创建不同的表示：比如根据用户选项构建不同配置的计算机。
4. 隐藏产品构建细节：客户端只跟指挥者交互，不需要知道具体构建步骤。

优点

1. 封装复杂构建过程。
2. 复用构建流程，避免代码重复。
3. 灵活性和可扩展性：通过更换具体建造者或指挥者，可以轻松改变产品表示。
4. 隐藏构建细节，降低客户端与产品的耦合。

缺点

1. 增加系统复杂度：引入新的类和接口。
2. 需要额外开发工作。
3. 不适用于简单对象。
4. 可能增加对象创建开销（尤其大量对象时）。

示例

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 语言中三种常见的创建型设计模式——工厂模式、原型模式和建造者模式，并给出了具体的代码示例和线程安全处理方式。理解这些模式的核心思想，可以帮助我们在实际项目中更灵活地组织对象创建逻辑，写出更易维护、更具扩展性的代码。