go实现四种设计模式

一、工厂模式

package main

import "fmt"

//工厂模式
type Factory interface {
	GetResult(a, b int) int
}

type Add struct {
}

func (p *Add) GetResult(a, b int) int {
	return a + b
}

type Sub struct {
}

func (p *Sub) GetResult(a, b int) int {
	return a - b
}

func CreatFactory(operateName string) Factory {
	switch operateName {
	case "+":
		return &Add{}
	case "-":
		return &Sub{}
	}
	return nil
}

func main() {
	a := CreatFactory("+").GetResult(5, 6)
	fmt.Println(a)
}

二、单例模式

package main

//单例模式
type Singelton struct {
}

var instance *Singelton

func GetInstance() *Singelton {
	if instance == nil {
		instance = &Singelton{}
	}
	return instance
}

//另一种就是使用sync.once（）

三、生产者消费者模式

package main

import (
	"fmt"
	"time"
)

func consumer(cname string, ch chan int) {

	//可以循环 for i := range ch 来不断从 channel 接收值，直到它被关闭。

	for i := range ch {
		fmt.Println("consumer-----------", cname, ":", i)
	}
	fmt.Println("ch closed.")
}

func producer(pname string, ch chan int) {
	for i := 0; i < 4; i++ {
		fmt.Println("producer--", pname, ":", i)
		ch <- i
	}
}

func main() {
	//用channel来传递"产品", 不再需要自己去加锁维护一个全局的阻塞队列
	ch := make(chan int)
	go producer("生产者1", ch)
	go producer("生产者2", ch)
	go consumer("消费者1", ch)
	go consumer("消费者2", ch)
	time.Sleep(10 * time.Second)
	close(ch)
	time.Sleep(10 * time.Second)
}

四、观察者模式

package pattern

import (
	"container/list"
)

type Subject interface {
	Attach(Observer) //注册观察者
	Detach(Observer) //释放观察者
	Notify()         //通知所有注册的观察者
}
type Observer interface {
	Update(Subject) //观察者进行更新状态
}

//implements Subject
type ConcreteSubject struct {
	observers *list.List
	value     int
}

func NewConcreteSubject() *ConcreteSubject {
	s := new(ConcreteSubject)
	s.observers = list.New()
	return s
}

func (s *ConcreteSubject) Attach(observe Observer) { //注册观察者
	s.observers.PushBack(observe)
}

func (s *ConcreteSubject) Detach(observer Observer) { //释放观察者
	for ob := s.observers.Front(); ob != nil; ob = ob.Next() {
		if ob.Value.(*Observer) == &observer {
			s.observers.Remove(ob)
			break
		}
	}
}

func (s *ConcreteSubject) Notify() { //通知所有观察者
	for ob := s.observers.Front(); ob != nil; ob = ob.Next() {
		ob.Value.(Observer).Update(s)
	}
}

func (s *ConcreteSubject) setValue(value int) {
	s.value = value
	s.Notify()
}

func (s *ConcreteSubject) getValue() int {
	return s.value
}

/**
 * 具体观察者 implements Observer
 *
 */
type ConcreteObserver1 struct {
}

func (c *ConcreteObserver1) Update(subject Subject) {
	println("ConcreteObserver1  value is ", subject.(*ConcreteSubject).getValue())
}

/**
 * 具体观察者 implements Observer
 *
 */
type ConcreteObserver2 struct {
}

func (c *ConcreteObserver2) Update(subject Subject) {
	println("ConcreteObserver2 value is ", subject.(*ConcreteSubject).getValue())
}

func main() {

	subject := NewConcreteSubject()
	observer1 := new(ConcreteObserver1)
	observer2 := new(ConcreteObserver2)
	subject.Attach(observer1)
	subject.Attach(observer2)
	subject.setValue(5)

}