Go设计模式与编程惯用法精选：go-patterns插件库使用指南

go-patterns简介

go-patterns是一个收集了Go语言中常用设计模式和编程惯用法的开源库，它提供了清晰的实现示例和最佳实践。这个库对于学习Go语言的设计模式和惯用法非常有帮助。

安装go-patterns

go get -u github.com/tmrts/go-patterns

常用设计模式实现

1. 工厂模式(Factory)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/creational/factory"
)

func main() {
	carFactory := factory.NewVehicleFactory()

	car := carFactory.NewVehicle(factory.Car)
	fmt.Println(car.Drive()) // 输出: Driving a car

	truck := carFactory.NewVehicle(factory.Truck)
	fmt.Println(truck.Drive()) // 输出: Driving a truck
}

2. 单例模式(Singleton)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/creational/singleton"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			instance := singleton.GetInstance()
			fmt.Printf("Instance address: %p\n", instance)
		}()
	}

	wg.Wait()
}

3. 观察者模式(Observer)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/behavioral/observer"
)

type MyObserver struct {
	ID int
}

func (o *MyObserver) OnNotify(e observer.Event) {
	fmt.Printf("Observer %d received event: %v\n", o.ID, e.Data)
}

func main() {
	notifier := observer.NewNotifier()

	// 注册观察者
	observer1 := &MyObserver{1}
	observer2 := &MyObserver{2}
	notifier.Register(observer1)
	notifier.Register(observer2)

	// 发送通知
	notifier.Notify(observer.Event{Data: "Something happened!"})
}

4. 装饰器模式(Decorator)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/structural/decorator"
)

func main() {
	simpleCoffee := &decorator.SimpleCoffee{}
	fmt.Printf("Cost: %f, Description: %s\n", 
		simpleCoffee.Cost(), simpleCoffee.Description())

	milkCoffee := &decorator.Milk{Coffee: simpleCoffee}
	fmt.Printf("Cost: %f, Description: %s\n", 
		milkCoffee.Cost(), milkCoffee.Description())

	sugarMilkCoffee := &decorator.Sugar{Coffee: milkCoffee}
	fmt.Printf("Cost: %f, Description: %s\n", 
		sugarMilkCoffee.Cost(), sugarMilkCoffee.Description())
}

常用编程惯用法

1. 函数选项模式(Functional Options)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/idiomatic/functional_options"
)

func main() {
	// 使用默认配置
	server1, _ := functional_options.NewServer("localhost")
	fmt.Printf("%+v\n", server1)

	// 使用自定义配置
	server2, _ := functional_options.NewServer("localhost",
		functional_options.WithPort(8080),
		functional_options.WithTimeout(30),
		functional_options.WithMaxConnections(100),
	)
	fmt.Printf("%+v\n", server2)
}

2. 错误处理(Error Handling)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/idiomatic/error_handling"
)

func main() {
	repo := error_handling.NewInMemoryRepository()

	if err := repo.Add("key1", "value1"); err != nil {
		fmt.Println("Error:", err)
	}

	value, err := repo.Get("key1")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Value:", value)
	}

	_, err = repo.Get("nonexistent")
	if err != nil {
		fmt.Println("Expected error:", err)
	}
}

3. 依赖注入(Dependency Injection)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/idiomatic/dependency_injection"
)

func main() {
	// 创建服务
	userService := dependency_injection.NewUserService(
		dependency_injection.NewInMemoryUserRepository(),
	)

	// 使用服务
	user, err := userService.Register("john@example.com", "password123")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Printf("Registered user: %+v\n", user)
}

高级模式

1. 管道模式(Pipeline)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/concurrency/pipeline"
)

func main() {
	// 创建管道
	p := pipeline.New(
		func(num int) int { return num * 2 },   // 乘以2
		func(num int) int { return num + 1 },   // 加1
		func(num int) int { return num * num }, // 平方
	)

	// 处理数据
	result := p.Process(3)
	fmt.Println(result) // 输出: 49 ((3*2 + 1)^2)
}

2. Worker池(Worker Pool)

package main

import (
	"fmt"
	"github.com/tmrts/go-patterns/concurrency/worker_pool"
	"time"
)

func main() {
	pool := worker_pool.New(3) // 创建3个worker的池

	// 提交任务
	for i := 0; i < 10; i++ {
		pool.Submit(func() {
			time.Sleep(1 * time.Second)
			fmt.Println("Task processed")
		})
	}

	// 等待所有任务完成
	pool.Wait()
	fmt.Println("All tasks completed")
}

总结

go-patterns库提供了Go语言中各种设计模式和编程惯用法的清晰实现，是学习和应用这些模式的优秀资源。通过使用这个库，开发者可以：

1. 快速掌握Go语言中的各种设计模式
2. 学习Go特有的编程惯用法
3. 在实际项目中应用这些模式
4. 避免常见的实现陷阱

建议读者结合具体业务场景，适当调整这些模式的实现，而不是生搬硬套。设计模式应该是解决问题的工具，而不是为了使用模式而使用模式。