Golang 设计模式

创建型模式

简单工厂模式

简单工厂模式是一种创建型设计模式。它定义了一个工厂类，这个工厂类负责创建产品对象。客户端（使用产品的代码）只需要向工厂类请求所需的产品，而不需要知道产品是如何创建的，这样就将产品的创建和使用分离，使得代码的结构更加清晰。
假设我们要创建一个图形绘制工具，首先定义一个图形接口，然后有不同的图形类实现这个接口。

图形接口

type Shape interface {
   
   
    Draw()
}

具体图形类：圆形

type Circle struct{
   
   }

func (c *Circle) Draw() {
   
   
    println("Drawing a circle")
}

具体图形类：矩形

type Rectangle struct{
   
   }

func (r *Rectangle) Draw() {
   
   
    println("Drawing a rectangle")
}

工厂类定义

接着创建简单工厂类，用于生产不同的图形。

  type ShapeFactory struct{
   
   }

  func (f *ShapeFactory) CreateShape(shapeType string) Shape {
   
   
      if shapeType == "circle" {
   
   
          return &Circle{
   
   }
      } else if shapeType == "rectangle" {
   
   
          return &Rectangle{
   
   }
      }
      return nil
  }

使用简单工厂模式

在主函数或者其他客户端代码中，可以这样使用工厂类来获取产品（图形）并使用。

  func main() {
   
   
      factory := &ShapeFactory{
   
   }
      circle := factory.CreateShape("circle")
      circle.Draw()

      rectangle := factory.CreateShape("rectangle")
      rectangle.Draw()
  }

抽象工厂模式

抽象工厂方法模式是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离，使得代码更具灵活性和可维护性。其核心在于有一个抽象工厂接口，该接口定义了创建一系列相关产品对象的抽象方法，然后由具体的工厂类来实现这些抽象方法，创建具体的产品对象。

1. 定义产品接口

首先，定义一系列相关的产品接口，比如这里假设有两种产品：ProductA和ProductB。

// ProductA接口，代表产品A的抽象
type ProductA interface {
   
   
    Use()
}

// ProductB接口，代表产品B的抽象
type ProductB interface {
   
   
    Use()
}

接口中定义了Use方法，用于表示产品的使用行为，具体的产品实现类需要实现这个方法。

2. 定义具体产品实现类

接着，创建具体的产品实现类，分别实现ProductA和ProductB接口。

// ConcreteProductA1是ProductA接口的一个具体实现
type ConcreteProductA1 struct{
   
   }

func (p *ConcreteProductA1) Use() {
   
   
    println("Using ConcreteProductA1")
}

// ConcreteProductA2是ProductA接口的另一个具体实现
type ConcreteProductA2 struct{
   
   }

func (p *ConcreteProductA2) Use() {
   
   
    println("Using ConcreteProductA2")
}

// ConcreteProductB1是ProductB接口的一个具体实现
type ConcreteProductB1 struct{
   
   }

func (p *ConcreteProductB1) Use() {
   
   
    println("Using ConcreteProductB1")
}

// ConcreteProductB2是ProductB接口的另一个具体实现
type ConcreteProductB2 struct{
   
   }

func (p *ConcreteProductB2) Use() {
   
   
    println("Using ConcreteProductB2")
}

这些具体产品类实现了各自接口的Use方法，定义了具体的使用行为，比如打印出不同的使用提示信息。

3. 定义抽象工厂接口

然后，定义抽象工厂接口，它声明了创建ProductA和ProductB的抽象方法。

// AbstractFactory接口，定义创建产品的抽象方法
type AbstractFactory interface {
   
   
    CreateProductA() ProductA
    CreateProductB() ProductB
}

4. 定义具体工厂实现类

再创建具体的工厂实现类，实现抽象工厂接口，根据具体工厂的逻辑来创建对应的具体产品。

// ConcreteFactory1是AbstractFactory接口的一个具体实现，用于创建特定组合的产品
type ConcreteFactory1 struct{
   
   }

func (f