当前位置：首页 > 文章列表 > Golang > Go教程 > Go语言实战！手把手教你搞定Golang常用设计模式

Go语言实战！手把手教你搞定Golang常用设计模式

2025-06-20 12:12:18 0浏览收藏

本文深入探讨了Go语言设计模式的实战应用，旨在帮助开发者掌握Golang常用设计模式，提升代码质量和可维护性。文章首先阐述了Go语言设计模式的核心思想，即利用Go语言的简洁语法和强大的并发能力解决常见的软件设计问题。随后，详细介绍了创建型模式（如单例、工厂、建造者）、结构型模式（如适配器、装饰器、外观）和行为型模式（如观察者、策略、模板方法）在Go语言中的具体实现方式，并给出了相应的代码示例。同时，文章强调了在Go语言中使用设计模式应适度，避免过度设计，优先考虑简单直接的“Go式”解决方案，以确保代码的简洁性和可读性。通过学习本文，读者可以更好地理解和运用Go语言设计模式，构建出更健壮、更高效的系统。

Go语言设计模式是利用Go特性解决常见软件设计问题的方法，其核心在于结合Go简洁语法和并发能力。1. 创建型模式如单例通过sync.Once实现，工厂通过接口与函数实现，建造者通过结构体链式方法构建复杂对象；2. 结构型模式如适配器用组合转换接口，装饰器动态添加职责，外观封装复杂逻辑提供统一入口；3. 行为型模式如观察者用channel和goroutine实现通知机制，策略通过接口封装算法，模板方法用匿名函数定义执行骨架。Go中使用设计模式应适度，避免过度复杂化代码，优先采用简单直接的“Go式”解决方案。

Go语言设计模式实战_golang常用模式教程

Go语言设计模式，说白了，就是用Go的特性，把一些常见的软件设计问题给漂亮地解决了。与其说是“设计模式”，不如说是“Go式解决问题”，更贴切。

解决方案

Go的设计模式，其实很大程度上受益于Go本身简洁的语法和强大的并发能力。比如，单例模式在Go里实现起来就比Java简单得多，因为Go的sync.Once天生就是为这个设计的。

创建型模式： 这类模式主要解决对象创建的问题，让你能更灵活地控制对象的生成过程。

单例模式 (Singleton): 确保一个类只有一个实例，并提供一个全局访问点。Go里用sync.Once就能轻松实现。

package singleton

import "sync"

type singleton struct {
}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

工厂模式 (Factory): 定义一个创建对象的接口，让子类决定实例化哪个类。Go里可以用接口和函数来实现。

package factory

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d *Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c *Cat) Speak() string {
    return "Meow!"
}

func NewAnimal(animalType string) Animal {
    switch animalType {
    case "dog":
        return &Dog{}
    case "cat":
        return &Cat{}
    default:
        return nil
    }
}

建造者模式 (Builder): 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Go里可以定义一个Builder接口，然后实现不同的Builder。

package builder

type House struct {
    Walls  int
    Doors  int
    Windows int
    Garage bool
}

type HouseBuilder interface {
    SetWalls(int) HouseBuilder
    SetDoors(int) HouseBuilder
    SetWindows(int) HouseBuilder
    SetGarage(bool) HouseBuilder
    Build() House
}

type ConcreteHouseBuilder struct {
    walls  int
    doors  int
    windows int
    garage bool
}

func (b *ConcreteHouseBuilder) SetWalls(walls int) HouseBuilder {
    b.walls = walls
    return b
}

func (b *ConcreteHouseBuilder) SetDoors(doors int) HouseBuilder {
    b.doors = doors
    return b
}

func (b *ConcreteHouseBuilder) SetWindows(windows int) HouseBuilder {
    b.windows = windows
    return b
}

func (b *ConcreteHouseBuilder) SetGarage(garage bool) HouseBuilder {
    b.garage = garage
    return b
}

func (b *ConcreteHouseBuilder) Build() House {
    return House{
        Walls:  b.walls,
        Doors:  b.doors,
        Windows: b.windows,
        Garage: b.garage,
    }
}

结构型模式： 这类模式关注如何组合对象，形成更大的结构。

适配器模式 (Adapter): 将一个类的接口转换成客户希望的另外一个接口。Go里用组合来实现。

package adapter

type LegacyPrinter interface {
    Print(string) string
}

type MyLegacyPrinter struct{}

func (l *MyLegacyPrinter) Print(s string) string {
    return "Legacy Printer: " + s
}

type ModernPrinter interface {
    PrintStored() string
}

type PrinterAdapter struct {
    LegacyPrinter LegacyPrinter
    Msg string
}

func (p *PrinterAdapter) PrintStored() string {
    if p.LegacyPrinter != nil {
        return p.LegacyPrinter.Print(p.Msg)
    }
    return p.Msg
}

装饰器模式 (Decorator): 动态地给一个对象添加一些额外的职责。Go里用组合和接口来实现。

package decorator

type Component interface {
    Operation() string
}

type ConcreteComponent struct{}

func (c *ConcreteComponent) Operation() string {
    return "ConcreteComponent"
}

type Decorator struct {
    Component Component
}

func (d *Decorator) Operation() string {
    return d.Component.Operation()
}

type ConcreteDecoratorA struct {
    Decorator
}

func (d *ConcreteDecoratorA) Operation() string {
    return "ConcreteDecoratorA(" + d.Decorator.Operation() + ")"
}

type ConcreteDecoratorB struct {
    Decorator
}

func (d *ConcreteDecoratorB) Operation() string {
    return "ConcreteDecoratorB(" + d.Decorator.Operation() + ")"
}

外观模式 (Facade): 为子系统中的一组接口提供一个统一的入口。Go里就是创建一个简单的结构体，封装复杂的逻辑。

package facade

type CPU struct{}

func (c *CPU) Start() {
    // ...
}

type Memory struct{}

func (m *Memory) Load() {
    // ...
}

type HardDrive struct{}

func (h *HardDrive) ReadData() {
    // ...
}

type ComputerFacade struct {
    cpu CPU
    memory Memory
    hardDrive HardDrive
}

func (c *ComputerFacade) Start() {
    c.cpu.Start()
    c.memory.Load()
    c.hardDrive.ReadData()
}

行为型模式： 这类模式关注对象之间的职责分配和算法。

观察者模式 (Observer): 定义对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。Go里用channel和goroutine来实现。

package observer

type Observer interface {
    Update(string)
}

type Subject interface {
    Attach(Observer)
    Detach(Observer)
    Notify(string)
}

type ConcreteSubject struct {
    observers []Observer
}

func (s *ConcreteSubject) Attach(observer Observer) {
    s.observers = append(s.observers, observer)
}

func (s *ConcreteSubject) Detach(observer Observer) {
    // Implementation to remove observer
}

func (s *ConcreteSubject) Notify(message string) {
    for _, observer := range s.observers {
        observer.Update(message)
    }
}

type ConcreteObserver struct {
    name string
}

func (o *ConcreteObserver) Update(message string) {
    // ...
}

策略模式 (Strategy): 定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。Go里用接口来实现。

package strategy

type Strategy interface {
    Execute(int, int) int
}

type AddStrategy struct{}

func (a *AddStrategy) Execute(a1, a2 int) int {
    return a1 + a2
}

type SubtractStrategy struct{}

func (s *SubtractStrategy) Execute(a1, a2 int) int {
    return a1 - a2
}

type Context struct {
    strategy Strategy
}

func (c *Context) SetStrategy(strategy Strategy) {
    c.strategy = strategy
}

func (c *Context) ExecuteStrategy(a1, a2 int) int {
    return c.strategy.Execute(a1, a2)
}

模板方法模式 (Template Method): 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Go里可以用匿名函数来实现，虽然和传统OO语言的模板方法略有不同。

package template

type Template interface {
    Step1()
    Step2()
    Hook()
}

type ConcreteTemplate struct {
    Template
}

func (c *ConcreteTemplate) Step1() {
    // ...
}

func (c *ConcreteTemplate) Step2() {
    // ...
}

func (c *ConcreteTemplate) Hook() {
    // Optional hook
}

func ExecuteTemplate(t Template) {
    t.Step1()
    t.Step2()
    t.Hook()
}