Golang 常用的五种创建型设计模式
Golang 常用的五种创建型设计模式
原创 Go Official Blog Go Official Blog
2024年10月18日 19:10 中国香港 听全文
在 Go 中，创建设计模式有助于管理对象的创建，并控制对象的实例化方式。这些模式在对象创建过程复杂或需要特殊处理时特别有用。以下是 Go 中常用的主要创建模式：
单例模式
单例模式确保一个类只有一个实例，并提供一个全局访问点。
如何实现
定义一个结构，并将其作为单个实例。
为该结构创建一个全局变量，但不要立即将其初始化。
使用 sync.Once 确保实例只创建一次，即使在多线程情况下也是如此。
提供一个全局函数来返回实例。
以下是实现单例模式的基本示例:
package main
import (
"fmt"
"sync"
)
type (
singleton struct {
data string
}
)
var instance *singleton
var once sync.Once
// Function to return the single instance
func GetInstance() *singleton {
// Use sync.Once to ensure the instance is created only once
once.Do(func() {
instance = &singleton{data: "This is a singleton"}
})
return instance
}
func main() {
s1 := GetInstance()
s2 := GetInstance()
// Both should point to the same instance
fmt.Println(s1 == s2) // true
fmt.Println(s1.data) // "This is a singleton"
}
sync.Once 可确保实例只创建一次，即使在并发调用 GetInstance 的情况下也是如此。
工厂方法模式
工厂方法模式定义了创建对象的接口，但允许子类改变将创建的对象类型。在 Go 中，这可以通过创建工厂函数来实现。这种设计模式提供一种将实例化逻辑委托给子类的方法，从而可以灵活地创建对象。
实现步骤：
创建一个为不同对象定义通用行为的接口。
创建多个实现此接口的结构体。
创建一个函数（工厂方法），接收一些输入（如类型）并返回相应结构的实例。
以下是实现工厂方法模式的基本示例:
package main
import (
"fmt"
)
type Animal interface {
Speak() string
}
Dog struct{}
Cat struct{}
)
func (d Dog) Speak() string {
return "Woof!"
}
func (c Cat) Speak() string {
return "Meow!"
}
func AnimalFactory(animalType string) Animal {
if animalType == "dog" {
return &Dog{}
} else if animalType == "cat" {
return &Cat{}
}
return nil
}
func main() {
dog := AnimalFactory("dog")
fmt.Println(dog.Speak()) // Woof!
cat := AnimalFactory("cat")
fmt.Println(cat.Speak()) // Meow!
}
工厂方法允许创建不同类型的对象，但用户端隐藏了创建逻辑。当对象创建过程比较复杂，需要进行抽象时，这种模式尤其有用。
抽象工厂模式
抽象工厂（Abstract Factory）提供了一个接口，用于创建相关或依赖对象的族，而无需指定它们的具体类。在 Go 中，可以通过定义不同的工厂接口来实现它。
当系统需要独立于其对象的创建、组成和表示方式时，它就非常有用。它允许创建相关对象族。
以下是实现抽象工厂模式的基本示例:
package main
import (
"fmt"
)
// Define an abstract factory
type (
GUIFactory interface {
CreateButton() Button
CreateCheckbox() Checkbox
}
)
// Define interfaces for products
type (
Button interface {
Press() string
}
Checkbox interface {
Check() string
}
// Implement concrete products for Windows
WindowsButton struct{}
WindowsCheckbox struct{}
// Implement concrete products for Mac
MacButton struct{}
MacCheckbox struct{}
// Implement factories for each platform
WindowsFactory struct{}
MacFactory struct{}
)
func (w *WindowsButton) Press() string { return "Windows Button Pressed" }
func (w *WindowsCheckbox) Check() string { return "Windows Checkbox Checked" }
func (m *MacButton) Press() string { return "Mac Button Pressed" }
func (m *MacCheckbox) Check() string { return "Mac Checkbox Checked" }
func (w *WindowsFactory) CreateButton() Button { return &WindowsButton{} }
func (w *WindowsFactory) CreateCheckbox() Checkbox { return &WindowsCheckbox{} }
func (m *MacFactory) CreateButton() Button { return &MacButton{} }
func (m *MacFactory) CreateCheckbox() Checkbox { return &MacCheckbox{} }
func main() {
// Get a Windows factory
var wf GUIFactory = &WindowsFactory{}
button := wf.CreateButton()
checkbox := wf.CreateCheckbox()
fmt.Println(button.Press()) // Output: Windows Button Pressed
fmt.Println(checkbox.Check()) // Output: Windows Checkbox Checked
var mf GUIFactory = &MacFactory{}
button = mf.CreateButton()
checkbox = mf.CreateCheckbox()
fmt.Println(button.Press()) // Output: Mac Button Pressed
fmt.Println(checkbox.Check()) // Output: Mac Checkbox Checked
}
Builder 模式
构建器模式将复杂对象的构建与其表示分离开来，允许同一构建过程创建不同的表示。它能解决问题：复杂的对象通常是一步一步构建的。构建器模式为创建此类对象提供了灵活的解决方案，分解了实例化过程。
以下是实现构建器模式的基本示例:
package main
import (
"fmt"
)
// Product to be built
type House struct {
windows string
doors string
roof string
}
// Concrete builder for a villa
type VillaBuilder struct {
house House
}
// Director controls the building process
type Director struct {
builder HouseBuilder
}
)
// Builder interface
type HouseBuilder interface {
SetWindows() HouseBuilder
SetDoors() HouseBuilder
SetRoof() HouseBuilder
Build() *House
}
func (v *VillaBuilder) SetWindows() HouseBuilder {
v.house.windows = "Villa Windows"
return v
}
func (v *VillaBuilder) SetDoors() HouseBuilder {
v.house.doors = "Villa Doors"
return v
}
func (v *VillaBuilder) SetRoof() HouseBuilder {
v.house.roof = "Villa Roof"
return v
}
func (v *VillaBuilder) Build() *House {
return &v.house
}
func (d *Director) Construct() *House {
return d.builder.SetWindows().SetDoors().SetRoof().Build()
}
func main() {
director := &Director{}
// Build a villa
v_builder := &VillaBuilder{}
director.builder = v_builder
villa := director.Construct()
fmt.Println(*villa) // Output: {Villa Windows Villa Doors Villa Roof}
}
在创建需要大量可选配置的复杂对象时，创建者模式非常有用。
原型模式
原型模式允许通过复制现有对象（原型）来创建新对象，而不是从头开始创建。当创建一个新对象的成本很高，而现有对象又可以克隆重用时，原型模式就派上用场了。
以下是实现原型模式的基本示例
package main
import (
"fmt"
)
// Cloneable interface
type (
Cloneable interface {
Clone() Cloneable
}
)
// Concrete struct (prototype)
type (
Product struct {
name string
category string
}
)
// Clone method creates a copy of the Product
func (p *Product) Clone() Cloneable {
return &Product{name: p.name, category: p.category}
}
func (p *Product) SetName(name string) {
p.name = name
}
func (p *Product) GetDetails() string {
return fmt.Sprintf("Product Name: %s, Category: %s", p.name, p.category)
}
func main() {
// Original product
original := &Product{name: "Phone", category: "Electronics"}
fmt.Println(original.GetDetails()) // Output: Product Name: Phone, Category: Electronics
// Clone the product and change its name
cloned := original.Clone().(*Product)
cloned.SetName("Smartphone")
fmt.Println(cloned.GetDetails()) // Output: Product Name: Smartphone, Category: Electronics
}
当创建对象的成本很高，而你又想通过复制现有对象来创建多个类似对象时，原型模式就很有效。这种模式通过克隆现有实例来简化对象的创建，而不是从头开始创建新实例。
总结
每种模式都有其特定的用例，选择恰当的设计模式会使代码更有条理、可重用且更易于维护！
Go Official Blog
你的肯定是对我最大的鼓励
阅读原文
阅读 630
