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

 

​