Golang视角下的设计模式

单例模式:

Gloang的单例模式该怎么写？随手写一个，不错，立马写出来了。但这个代码有什么问题呢？多个协程同时执行这段代码就会出现问题：instance可能会被赋值多次，这段代码是线程不安全的代码。那么如何保证在多线程下只执行一次呢？条件反射：加锁。。。加锁是可以解决问题。但不是最优的方案，因为如果有1W并发，每一个线程都竞争锁，同一时刻只有一个线程能拿到锁，其他的全部阻塞等待。让原本想并发得飞起来变成了一切认怂串行化。通过check-lock-check方式可以减少竞争。还有其他方式，利用sync/atomic和sync/once 这里只给出代码

1. func NewSingleton() *singleton {
2. if instance == nil {
3. instance = &singleton{}
4. }
5. return instance
6. }

复制代码

1. func NewSingleton() *singleton {
2. l.Lock() // lock
3. defer l.Unlock()
4. if instance == nil { // check
5. instance = &singleton{}
6. }
7. return instance
8. }

复制代码

1. func NewSingleton() *singleton {
2. if instance == nil { // check
3. l.Lock() // lock
4. defer l.Unlock()
5. if instance == nil { // check
6. instance = &singleton{}
7. }
8. }
9. return instance
10. }

复制代码

1. func NewSingleton() *singleton {
2. if atomic.LoadUInt32(&initialized) == 1 {
3. return instance
4. }
5. mu.Lock()
6. defer mu.Unlock()
7. if initialized == 0 {
8. instance = &singleton{}
9. atomic.StoreUint32(&initialized, 1)
10. }
11. return instance
12. }

复制代码

1. func NewSingleton() *singleton {
2. once.Do(func() {
3. instance = &singleton{}
4. })
5. return instance
6. }

复制代码

工厂模式:

工厂根据条件产生不同功能的类。工厂模式使用经常使用在替代new的场景中，让工厂统一根据不同条件生产不同的类。工厂模式在解耦方面将使用者和产品之间的依赖推给了工厂，让工厂承担这种依赖关系。工厂模式又分为简单工厂，抽象工厂。golang实现一个简单工厂模式如下:

1. package main
2. import (
3. "fmt"
4. )
5. type Op interface {
6. getName() string
7. }
8. type A struct {
9. }
10. type B struct {
11. }
12. type Factory struct {
13. }
14. func (a *A) getName() string {
15. return "A"
16. }
17. func (b *B) getName() string {
18. return "B"
19. }
20. func (f *Factory) create(name string) Op {
21. switch name {
22. case `a`:
23. return new(A)
24. case `b`:
25. return new(B)
26. default:
27. panic(`name not exists`)
28. }
29. return nil
30. }
31. func main() {
32. var f = new(Factory)
33. p := f.create(`a`)
34. fmt.Println(p.getName())
35. p = f.create(`b`)
36. fmt.Println(p.getName())
37. }

复制代码

依赖注入:

具体含义是:当某个角色(可能是一个实例，调用者)需要另一个角色(另一个实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在这种场景下，创建被调用者实例的工作通常由容器(IoC)来完成，然后注入调用者，因此也称为依赖注入。 Golang利用函数f可以当做参数来传递，同时配合reflect包拿到参数的类型，然后根据调用者传来的参数和类型匹配上之后，最后通过reflect.Call()执行具体的函数。下面的代码来自：https://www.studygolang.com/articles/4957 这篇文章上。

1. package main
3. import (
4. "fmt"
5. "reflect"
6. )
8. var inj *Injector
10. type Injector struct {
11. mappers map[reflect.Type]reflect.Value // 根据类型map实际的值
12. }
14. func (inj *Injector) SetMap(value interface{}) {
15. inj.mappers[reflect.TypeOf(value)] = reflect.ValueOf(value)
16. }
18. func (inj *Injector) Get(t reflect.Type) reflect.Value {
19. return inj.mappers[t]
20. }
22. func (inj *Injector) Invoke(i interface{}) interface{} {
23. t := reflect.TypeOf(i)
24. if t.Kind() != reflect.Func {
25. panic("Should invoke a function!")
26. }
27. inValues := make([]reflect.Value, t.NumIn())
28. for k := 0; k < t.NumIn(); k++ {
29. inValues[k] = inj.Get(t.In(k))
30. }
31. ret := reflect.ValueOf(i).Call(inValues)
32. return ret
33. }
35. func Host(name string, f func(a int, b string) string) {
36. fmt.Println("Enter Host:", name)
37. fmt.Println(inj.Invoke(f))
38. fmt.Println("Exit Host:", name)
39. }
41. func Dependency(a int, b string) string {
42. fmt.Println("Dependency: ", a, b)
43. return `injection function exec finished ...`
44. }
46. func main() {
47. // 创建注入器
48. inj = &Injector{make(map[reflect.Type]reflect.Value)}
49. inj.SetMap(3030)
50. inj.SetMap("zdd")
52. d := Dependency
53. Host("zddhub", d)
55. inj.SetMap(8080)
56. inj.SetMap("www.zddhub.com")
57. Host("website", d)
58. }

复制代码

装饰器模式:

装饰器模式：允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。我们使用最为频繁的场景就是http请求的处理：对http请求做cookie校验。

1. package main
3. import (
4. "fmt"
5. "log"
6. "net/http"
7. )
9. func autoAuth(h http.HandlerFunc) http.HandlerFunc {
10. return func(w http.ResponseWriter, r *http.Request) {
11. cookie, err := r.Cookie("Auth")
12. if err != nil || cookie.Value != "Authentic" {
13. w.WriteHeader(http.StatusForbidden)
14. return
15. }
16. h(w, r)
17. }
18. }
20. func hello(w http.ResponseWriter, r *http.Request) {
21. fmt.Fprintf(w, "Hello, World! "+r.URL.Path)
22. }
24. func main() {
25. http.HandleFunc("/hello", autoAuth(hello))
26. err := http.ListenAndServe(":5666", nil)
27. if err != nil {
28. log.Fatal("ListenAndServe: ", err)
29. }
30. }

复制代码

还有很多其他模式，这里不一一给出了，写这篇文章的目的是想看看这些模式在golang中是如何体现出来的，框架或者类库应该是设计模式常常出没的地方。深入理解设计模式有助于代码的抽象，复用和解耦，让代码与代码之间更加低耦合。