Go 之常见的几种设计模式

学一学Go中常见的几种设计模式和对应的示例

单例模式

确保一个类型只有一个实例,同时提供一个全局访问点。

Go 复制代码
package main

import "fmt"

type Singleton struct {
	data string
}

var instance *Singleton

func GetInstance() *Singleton {
	if instance == nil {
		instance = &Singleton{data: "singleton instance"}
	}
	return instance
}

func main() {
	singleton1 := GetInstance()
	singleton2 := GetInstance()
	if singleton1 == singleton2 {
		fmt.Println("Both singletons are the same instance")
		// Both singletons are the same instance
	} else {
		fmt.Println("Different instance")
	}
}

工厂模式

通过工厂方法创建对象,而无需指定创建对象的具体类。虽然创建的对象各不相同,但是由于他们都实现了相同的接口,对应的接口类型是一样的。

Go 复制代码
package main

import "fmt"

type Product interface {
	GetInfo() string
}

type ConcreteProduct1 struct {
}

func (p *ConcreteProduct1) GetInfo() string {
	return "Product 1"
}

type ConcreteProduct2 struct {
}

func (p *ConcreteProduct2) GetInfo() string {
	return "Product 2"
}

type Factory struct {
}

func (f *Factory) CreateProduct(productType int) Product {
	switch productType {
	case 1:
		return &ConcreteProduct1{}
	case 2:
		return &ConcreteProduct2{}
	default:
		return nil
	}
}

func main() {
	factory := &Factory{}
	product1 := factory.CreateProduct(1)
	product2 := factory.CreateProduct(2)

	fmt.Println(product1.GetInfo()) // Product 1
	fmt.Println(product2.GetInfo()) // Product 2
}

装饰器模式

允许向现有对象添加新功能,同时保持其结构不变。主要是使用结构体的嵌套实现继承。

Go 复制代码
package main

import "fmt"

type Component interface {
	Operation() string
}

type ConcreteComponent struct {
}

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

type Decorator struct {
	Component
}

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

func main() {
	component := &ConcreteComponent{}
	decorator := &Decorator{Component: component}

	fmt.Println(component.Operation()) // Concrete Component
	fmt.Println(decorator.Operation()) // Decorator Concrete Component
}

观察者模式

定义了对象之间的一对多依赖关系,使得当一个对象改变状态时,其所有依赖对象都会收到通知并自动更新。

Go 复制代码
package main

import "fmt"

type Observer interface {
	Update(string)
}

type Subject struct {
	observers []Observer
	state string
}

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

func (s *Subject) SetState(state string)  {
	s.state = state
	s.Notify()
}

func (s *Subject) Notify()  {
	for _, observer := range s.observers {
		observer.Update(s.state)
	}
}

type ConcreteObserver struct {
	name string
}

func (co *ConcreteObserver) Update(state string)  {
	fmt.Printf("Observer %s received the state: %s\n", co.name, state)
}


func main() {
	subject := &Subject{}
	observer1 := &ConcreteObserver{name: "Observer 1"}
	observer2 := &ConcreteObserver{name: "Observer 2"}

	subject.Attach(observer1)
	subject.Attach(observer2)

	subject.SetState("new state")
	// Observer Observer 1 received the state: new state
	// Observer Observer 2 received the state: new state
}
相关推荐
又菜又爱玩呜呜呜~3 小时前
go使用反射获取http.Request参数到结构体
开发语言·http·golang
SamDeepThinking3 小时前
用设计模式重构核心业务代码的一次实战
java·后端·设计模式
青草地溪水旁3 小时前
设计模式(C++)详解——建造者模式(2)
c++·设计模式·建造者模式
希望20175 小时前
Golang | http/server & Gin框架简述
http·golang·gin
o0向阳而生0o5 小时前
102、23种设计模式之装饰器模式(11/23)
设计模式·装饰器模式
宁静致远20215 小时前
【C++设计模式】第五篇:装饰器模式
c++·设计模式·装饰器模式
IT灰猫8 小时前
C++轻量级配置管理器升级版
开发语言·c++·设计模式·配置管理·ini解析
大飞pkz8 小时前
【设计模式】题目小练2
开发语言·设计模式·c#·题目小练
NG WING YIN12 小时前
Golang關於信件的
开发语言·深度学习·golang