使用Golang实现开发中常用的【实例设计模式】

使用Golang实现开发中常用的【实例设计模式】

设计模式是解决常见问题的模板，可以帮助我们提升思维能力，编写更高效、可维护性更强的代码。

单例模式：

描述：确保一个类只有一个实例，并提供一个全局访问点。
优点：节省资源，避免重复创建对象。
缺点：单例对象通常是全局可访问的，容易引起耦合。

package singleton

import (
"sync"
)

type Singleton struct {
value string
}

var instance *Singleton
var once sync.Once

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

func (s *Singleton) SetValue(value string) {
s.value = value
}

func (s *Singleton) GetValue() string {
return s.value
}

工厂模式：

描述：提供一个创建对象的接口，但由子类决定实例化哪一个类。
优点：将对象的创建和使用分离，提高代码的灵活性。
缺点：增加了代码的复杂性。

package factory

type Product interface {
Use()
}

type ConcreteProductA struct{}

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

type ConcreteProductB struct{}

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

type Factory interface {
CreateProduct() Product
}

type ConcreteFactoryA struct{}

func (f *ConcreteFactoryA) CreateProduct() Product {
return &ConcreteProductA{}
}

type ConcreteFactoryB struct{}

func (f *ConcreteFactoryB) CreateProduct() Product {
return &ConcreteProductB{}
}

观察者模式：

描述：定义了对象之间的一对多依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会得到通知。
优点：实现了对象之间的松耦合。
缺点：如果观察者数量过多，通知过程可能会变得复杂。

package observer

type Subject interface {
RegisterObserver(observer Observer)
RemoveObserver(observer Observer)
NotifyObservers()
}

type Observer interface {
Update(data string)
}

type ConcreteSubject struct {
observers []Observer
state     string
}

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

func (s *ConcreteSubject) RemoveObserver(observer Observer) {
for i, obs := range s.observers {
if obs == observer {
s.observers = append(s.observers[:i], s.observers[i+1:]...)
break
}
}
}

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

func (s *ConcreteSubject) SetState(state string) {
s.state = state
s.NotifyObservers()
}

type ConcreteObserver struct {
name string
}

func (o *ConcreteObserver) Update(data string) {
println(o.name, "received:", data)
}

策略模式：

描述：定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。
优点：算法的变化独立于使用算法的客户。
缺点：增加了代码的复杂性。

package strategy

type Strategy interface {
Execute(data string) string
}

type Context struct {
strategy Strategy
}

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

func (c *Context) ExecuteStrategy(data string) string {
return c.strategy.Execute(data)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) string {
return "ConcreteStrategyA executed with " + data
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) string {
return "ConcreteStrategyB executed with " + data
}

装饰者模式：

描述：动态地给一个对象添加一些额外的职责，而不必修改对象结构。
优点：增加了代码的灵活性和可扩展性。
缺点：增加了代码的复杂性。

package decorator

type Component interface {
Operation() string
}

type ConcreteComponent struct{}

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

type Decorator struct {
component Component
}

func NewDecorator(component Component) *Decorator {
return &Decorator{component: component}
}

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

type ConcreteDecoratorA struct {
Decorator
}

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

type ConcreteDecoratorB struct {
Decorator
}

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

代理模式：

描述：为其他对象提供一种代理以控制对这个对象的访问。
优点：增加了安全性和灵活性。
缺点：增加了代码的复杂性。

package proxy

type Subject interface {
Request() string
}

type RealSubject struct{}

func (r *RealSubject) Request() string {
return "RealSubject handling request"
}

type Proxy struct {
realSubject *RealSubject
}

func NewProxy() *Proxy {
return &Proxy{
realSubject: &RealSubject{},
}
}

func (p *Proxy) Request() string {
// Pre-processing
println("Proxy: Checking access prior to firing a real request.")
// Delegate to the real subject
result := p.realSubject.Request()
// Post-processing
println("Proxy: Logging the time of request.")
return result
}

分别调用不同模式的对象实例：

package main

import (
"fmt"
"singleton"
"factory"
"observer"
"strategy"
"decorator"
"proxy"
)

func main() {
// 单例模式
singleton.GetInstance().SetValue("Hello, Singleton!")
fmt.Println(singleton.GetInstance().GetValue())

// 工厂模式
factoryA := &factory.ConcreteFactoryA{}
productA := factoryA.CreateProduct()
productA.Use()

factoryB := &factory.ConcreteFactoryB{}
productB := factoryB.CreateProduct()
productB.Use()

// 观察者模式
subject := &observer.ConcreteSubject{}
observerA := &observer.ConcreteObserver{name: "ObserverA"}
observerB := &observer.ConcreteObserver{name: "ObserverB"}

subject.RegisterObserver(observerA)
subject.RegisterObserver(observerB)

subject.SetState("New State")

// 策略模式
context := &strategy.Context{}
strategyA := &strategy.ConcreteStrategyA{}
strategyB := &strategy.ConcreteStrategyB{}

context.SetStrategy(strategyA)
fmt.Println(context.ExecuteStrategy("Data"))

context.SetStrategy(strategyB)
fmt.Println(context.ExecuteStrategy("Data"))

// 装饰者模式
component := &decorator.ConcreteComponent{}
decoratorA := &decorator.ConcreteDecoratorA{Decorator: *decorator.NewDecorator(component)}
decoratorB := &decorator.ConcreteDecoratorB{Decorator: *decorator.NewDecorator(decoratorA)}

fmt.Println(decoratorB.Operation())

// 代理模式
proxy := proxy.NewProxy()
fmt.Println(proxy.Request())
}

原文地址：https://blog.csdn.net/qq_37106501/article/details/143582650

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！