golang创造型设计模式

设计模式是软件开发过程中常用的一种思想，它可以帮助开发者更好地组织和设计代码，提高代码的可读性、可维护性和可扩展性。而在Golang中，也存在着一些常用的创造型设计模式，本文将介绍其中的几种。

单例模式

单例模式是一种常用的设计模式，在整个系统运行过程中只有一个实例对象可供使用。在Golang中，我们可以通过使用全局变量和sync.Once来实现单例模式：

package main

import (
    "fmt"
    "sync"
)

type singleton struct {
    data string
}

var instance *singleton
var once sync.Once

func getInstance() *singleton {
    once.Do(func() {
        instance = &singleton{"hello world"}
    })
    return instance
}

func main() {
    s1 := getInstance()
    s2 := getInstance()

    fmt.Println(s1 == s2) // 输出：true
}

在上面的例子中，我们使用了sync.Once来保证instance对象只被创建一次，从而实现了单例模式。

工厂模式

工厂模式是一种常用的创建型设计模式，它通过定义一个创建对象的接口，但具体的对象创建任务由子类来完成。在Golang中，可以使用接口和结构体的组合来实现工厂模式：

package main

import (
    "fmt"
)

type animal interface {
    Eat()
    Sleep()
}

type cat struct{}

func (c *cat) Eat() {
    fmt.Println("猫在吃鱼")
}

func (c *cat) Sleep() {
    fmt.Println("猫在睡觉")
}

type dog struct{}

func (d *dog) Eat() {
    fmt.Println("狗在吃骨头")
}

func (d *dog) Sleep() {
    fmt.Println("狗在睡觉")
}

func createAnimal(kind string) animal {
    switch kind {
    case "cat":
        return &cat{}
    case "dog":
        return &dog{}
    default:
        return nil
    }
}

func main() {
    a1 := createAnimal("cat")
    a2 := createAnimal("dog")

    a1.Eat() // 输出：猫在吃鱼
    a2.Sleep() // 输出：狗在睡觉
}

上面的例子中，我们通过定义animal接口和具体的cat、dog结构体来实现工厂模式。通过createAnimal函数根据不同的参数来创建不同的动物对象，从而实现了动态创建。

建造者模式

建造者模式是一种常用的创建型设计模式，它将一个复杂的对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。在Golang中，我们可以通过结构体的建造者方法来实现建造者模式：

package main

import "fmt"

type Product struct {
    partA string
    partB string
    partC string
}

func (p *Product) setPartA(part string) {
    p.partA = part
}

func (p *Product) setPartB(part string) {
    p.partB = part
}

func (p *Product) setPartC(part string) {
    p.partC = part
}

type Builder interface {
    buildPartA()
    buildPartB()
    buildPartC()
    getResult() *Product
}

type ConcreteBuilder struct {
    product *Product
}

func (cb *ConcreteBuilder) buildPartA() {
    cb.product.setPartA("Part A")
}

func (cb *ConcreteBuilder) buildPartB() {
    cb.product.setPartB("Part B")
}

func (cb *ConcreteBuilder) buildPartC() {
    cb.product.setPartC("Part C")
}

func (cb *ConcreteBuilder) getResult() *Product {
    return cb.product
}

type Director struct {
    builder Builder
}

func (d *Director) setBuilder(builder Builder) {
    d.builder = builder
}

func (d *Director) construct() *Product {
    d.builder.buildPartA()
    d.builder.buildPartB()
    d.builder.buildPartC()
    return d.builder.getResult()
}

func main() {
    builder := &ConcreteBuilder{}
    director := &Director{}

    director.setBuilder(builder)
    product := director.construct()

    fmt.Println(product.partA) // 输出：Part A
    fmt.Println(product.partB) // 输出：Part B
    fmt.Println(product.partC) // 输出：Part C
}

在上面的例子中，我们通过定义Builder接口和ConcreteBuilder结构体来实现建造者模式。通过Director的construct方法来组织和调用具体的建造者方法，从而创建出一个复杂对象。