石家庄制作网站西地那非片吃了能延时多久

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

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

单例模式：

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

package singletonimport ("sync"
)type Singleton struct {value string
}var instance *Singleton
var once sync.Oncefunc 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 factorytype 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 observertype Subject interface {RegisterObserver(observer Observer)RemoveObserver(observer Observer)NotifyObservers()
}type Observer interface {Update(data string)
}type ConcreteSubject struct {observers []Observerstate     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 = states.NotifyObservers()
}type ConcreteObserver struct {name string
}func (o *ConcreteObserver) Update(data string) {println(o.name, "received:", data)
}

策略模式：

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

package strategytype 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 decoratortype 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 proxytype 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-processingprintln("Proxy: Checking access prior to firing a real request.")// Delegate to the real subjectresult := p.realSubject.Request()// Post-processingprintln("Proxy: Logging the time of request.")return result
}

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

package mainimport ("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())
}