工厂模式三种类型：
一、简单工厂模式（Simple Factory）
定义： 用一个工厂类，根据传入的参数决定创建哪一种具体产品类实例。
面试说法： 由一个统一的工厂创建所有对象，增加新产品时需要修改工厂类，不符合OCP开闭原则。
OCP原则：
对扩展开放 （Open for extension）：软件中的功能应该允许通过新增代码来进行扩展。
对修改关闭（Closed for modification）：原有代码不应该被修改，以减少引入 bug 的风险。
Go 实现：
go
type PayMethod interface {
Pay(amount float64)
}
type AliPay struct{}
func (a *AliPay) Pay(amount float64) {
fmt.Println("使用支付宝支付", amount)
}
type WeChatPay struct{}
func (w *WeChatPay) Pay(amount float64) {
fmt.Println("使用微信支付", amount)
}
func PayFactory(channel string) PayMethod {
switch channel {
case "alipay":
return &AliPay{}
case "wechat":
return &WeChatPay{}
default:
return nil
}
}二、工厂方法模式（Factory Method）
定义： 把创建对象的逻辑下放到每个具体工厂类，遵循了开闭原则。
面试说法： 一个抽象工厂接口 + 多个具体工厂类，每种产品由对应工厂类负责创建。符合开闭原则，新增产品时不修改已有代码，只需新增工厂类。
Go 实现：
go
type PayMethod interface {
Pay(amount float64)
}
type PayFactory interface {
CreatePayMethod() PayMethod
}
type AliPay struct{}
func (a *AliPay) Pay(amount float64) {
fmt.Println("使用支付宝支付", amount)
}
type AliPayFactory struct{}
func (f *AliPayFactory) CreatePayMethod() PayMethod {
return &AliPay{}
}
type WeChatPay struct{}
func (w *WeChatPay) Pay(amount float64) {
fmt.Println("使用微信支付", amount)
}
type WeChatPayFactory struct{}
func (f *WeChatPayFactory) CreatePayMethod() PayMethod {
return &WeChatPay{}
}三、抽象工厂模式（Abstract Factory）
定义： 提供一系列产品创建的接口，每个具体工厂创建一整套产品。
面试说法： 用于创建一系列相关产品，适用于产品族的扩展。每个工厂可以返回多个产品实例，如 UI 工厂创建按钮、窗口、滚动条等。
Go 实现：
go
// 抽象产品
type Pay interface {
Pay(amount float64)
}
type Refund interface {
Refund(amount float64)
}
// 抽象工厂
type PayFactory interface {
CreatePay() Pay
CreateRefund() Refund
}
// 支付宝产品实现
type AliPay struct{}
func (a *AliPay) Pay(amount float64) {
fmt.Println("支付宝支付", amount)
}
type AliRefund struct{}
func (a *AliRefund) Refund(amount float64) {
fmt.Println("支付宝退款", amount)
}
// 支付宝工厂
type AliFactory struct{}
func (f *AliFactory) CreatePay() Pay {
return &AliPay{}
}
func (f *AliFactory) CreateRefund() Refund {
return &AliRefund{}
}面试中该如何答工厂模式的区别？
-
简单工厂模式
- 优点：结构简单，适用于产品数量较少、需求变化不频繁的场景。
- 缺点：不符合开闭原则，新增产品需要修改工厂代码。
- 应用场景：支付渠道种类少的项目、快速原型开发。
-
工厂方法模式
- 优点：符合开闭原则，新增产品时只需新增具体工厂类，扩展性好。
- 缺点：类的数量增加，结构相对复杂。
- 应用场景：产品频繁扩展变化的系统，例如支持多个支付渠道，未来还会新增。
-
抽象工厂模式
- 优点：可以创建一整套相关联的产品（产品族），一致性强。
- 缺点：不方便支持新增产品种类（每个工厂都要改），灵活性略低。
- 应用场景：跨平台开发、UI 工具包、数据库驱动（同一工厂生产连接器和执行器等）。
"简单工厂是最基本的一种模式，用一个工厂创建所有对象，不符合开闭原则。工厂方法将创建逻辑分离到每个工厂类，支持扩展。抽象工厂则用于生产一组相关产品，产品族统一，适合跨平台系统。"
工厂模式 ：✅ 通常只有一个抽象工厂接口 和多个具体工厂实现类 ，每个工厂创建一种产品 。
抽象工厂模式 ：✅ 有一个抽象工厂接口 ，多个具体工厂实现类 ，每个工厂创建一个产品族 。
✅ 强调产品之间的 "族" 关系（如 Windows 风格的按钮 + 复选框必须来自同一个工厂）。
go
// 抽象产品族
type Button interface { Click() }
type Checkbox interface { Check() }
// 具体产品（按族分类）
type WindowsButton struct{}
type WindowsCheckbox struct{}
type MacButton struct{}
type MacCheckbox struct{}
// 抽象工厂
type GUIFactory interface {
CreateButton() Button
CreateCheckbox() Checkbox
}
// 具体工厂
type WindowsFactory struct{} // 创建Windows风格的Button和Checkbox
type MacFactory struct{} // 创建Mac风格的Button和Checkbox四、单例模式（Singleton Pattern）
定义：
确保一个类只有一个实例，并提供一个全局访问点。
使用场景：
- 配置管理类
- 数据库连接池
- 日志处理类
- 缓存管理器
特点：
- 全局唯一
- 延迟初始化（懒汉）
- 线程安全
Go 语言实现（懒汉 + 线程安全）：
go
package singleton
import (
"sync"
)
type Singleton struct {
Name string
}
var (
instance *Singleton
once sync.Once
)
func GetInstance() *Singleton {
once.Do(func() {
instance = &Singleton{Name: "唯一实例"}
})
return instance
}单例模式确保某个类在整个系统中只有一个实例。常用
sync.Once来实现线程安全的延迟初始化。在场景如日志记录器、配置加载器中很常见。它的关键是将构造函数私有化，通过提供一个全局访问方法来获取实例。
饿汉
go
package singleton
type EagerSingleton struct {
Name string
}
var eagerInstance = &EagerSingleton{Name: "饿汉式单例"}
func GetEagerInstance() *EagerSingleton {
return eagerInstance
}
- 懒汉式 在第一次使用时才初始化，需要注意并发下的线程安全 ，Go 中推荐使用 sync.Once 来保证只初始化一次；
- 饿汉式 在程序启动时就创建 实例，线程安全但资源利用不够高效 。适合对资源敏感性不强的场景。
实际开发中，推荐懒汉式 + sync.Once 方式来兼顾延迟加载和线程安全。
五、代理模式（Proxy Pattern）
定义：
为其他对象提供一个"代理"以控制对该对象的访问。
使用场景：
- 访问控制（权限校验）
- 延迟加载（虚拟代理）
- 远程代理（RPC Stub）
- 缓存代理（避免重复计算）
Go 语言实现（以下载器为例，带缓存功能的代理）：
go
package proxy
import "fmt"
type Downloader interface {
Download(url string)
}
// 真实对象
type RealDownloader struct{}
func (r *RealDownloader) Download(url string) {
fmt.Println("正在下载：", url)
}
// 代理对象
type ProxyDownloader struct {
real *RealDownloader
cacheMap map[string]bool
}
func NewProxyDownloader() *ProxyDownloader {
return &ProxyDownloader{
real: &RealDownloader{},
cacheMap: make(map[string]bool),
}
}
func (p *ProxyDownloader) Download(url string) {
if p.cacheMap[url] {
fmt.Println("缓存命中：", url)
} else {
p.real.Download(url)
p.cacheMap[url] = true
}
}代理模式通过引入一个代理对象来控制对目标对象的访问。比如在缓存代理中，代理会先判断是否命中缓存，如果没有才真正访问目标对象。这样可以在不改动原有逻辑的情况下，增强对象的功能（控制、缓存、权限等）。