Go语言设计模式集合插件库Design Patterns in Go的使用

设计模式简介

设计模式是我们设计软件解决方案时解决问题的不同方法。当遇到以下情况时，设计模式可以帮助你优雅地构建代码：

• 有太多if/else条件？
• 需要实现多种初始化对象的方式？
• 编写了太多解析器？

需要注意的是，设计模式只是一组蓝图/建议，它们不是问题的确切解决方案，而是代码中应遵循的概念/约定。

Go实现的设计模式集合

这个库收集了多种可能在项目中帮助你的设计模式，所有模式都用Go语言实现。每个模式都包含一个详细的README文件描述该模式，因此你可以轻松地在任何编程语言中实现这些模式。

包含的设计模式

1. 工厂模式(Factory pattern)
2. 抽象工厂模式(Abstract Factory pattern)
3. 建造者模式(Builder Pattern)
4. 适配器模式(Adapter Pattern)
5. 桥接模式(Bridge Pattern)
6. 装饰器模式(Decorator Pattern)
7. 外观模式(Facade Pattern)
8. 享元模式(Flyweight Pattern)
9. 责任链模式(Chain of responsibility)

示例代码

工厂模式示例

package main

import "fmt"

// 定义一个接口
type Shape interface {
    Draw()
}

// 圆形实现
type Circle struct{}

func (c *Circle) Draw() {
    fmt.Println("Drawing a Circle")
}

// 方形实现
type Square struct{}

func (s *Square) Draw() {
    fmt.Println("Drawing a Square")
}

// 工厂函数
func GetShape(shapeType string) Shape {
    switch shapeType {
    case "circle":
        return &Circle{}
    case "square":
        return &Square{}
    default:
        return nil
    }
}

func main() {
    shape1 := GetShape("circle")
    shape1.Draw()
    
    shape2 := GetShape("square")
    shape2.Draw()
}

装饰器模式示例

package main

import "fmt"

// 基础组件接口
type Pizza interface {
    GetPrice() int
}

// 具体组件
type VeggiePizza struct{}

func (p *VeggiePizza) GetPrice() int {
    return 15
}

// 装饰器基类
type PizzaDecorator struct {
    pizza Pizza
}

func (d *PizzaDecorator) GetPrice() int {
    return d.pizza.GetPrice()
}

// 具体装饰器：芝士
type CheeseTopping struct {
    PizzaDecorator
}

func (c *CheeseTopping) GetPrice() int {
    return c.pizza.GetPrice() + 10
}

// 具体装饰器：番茄
type TomatoTopping struct {
    PizzaDecorator
}

func (t *TomatoTopping) GetPrice() int {
    return t.pizza.GetPrice() + 7
}

func main() {
    pizza := &VeggiePizza{}
    
    // 添加芝士
    pizzaWithCheese := &CheeseTopping{
        PizzaDecorator: PizzaDecorator{pizza: pizza},
    }
    
    // 添加番茄
    pizzaWithCheeseAndTomato := &TomatoTopping{
        PizzaDecorator: PizzaDecorator{pizza: pizzaWithCheese},
    }
    
    fmt.Printf("Total price: %d\n", pizzaWithCheeseAndTomato.GetPrice())
}

责任链模式示例

package main

import "fmt"

// 处理器接口
type Handler interface {
    SetNext(handler Handler)
    Handle(request string)
}

// 基础处理器
type BaseHandler struct {
    next Handler
}

func (b *BaseHandler) SetNext(handler Handler) {
    b.next = handler
}

// 具体处理器1
type FirstHandler struct {
    BaseHandler
}

func (f *FirstHandler) Handle(request string) {
    if request == "first" {
        fmt.Println("FirstHandler handled the request")
        return
    }
    if f.next != nil {
        f.next.Handle(request)
    }
}

// 具体处理器2
type SecondHandler struct {
    BaseHandler
}

func (s *SecondHandler) Handle(request string) {
    if request == "second" {
        fmt.Println("SecondHandler handled the request")
        return
    }
    if s.next != nil {
        s.next.Handle(request)
    }
}

func main() {
    first := &FirstHandler{}
    second := &SecondHandler{}
    
    first.SetNext(second)
    
    first.Handle("second") // 将由SecondHandler处理
}

这些示例展示了如何在Go中实现常见的设计模式。你可以根据实际需求调整和扩展这些模式来构建更复杂的系统。