golang 装饰器模式详解

二、Http 相关的装饰器的例子

func WithServerHeader(h http.HandlerFunc) http.HandlerFunc {
   return func(writer http.ResponseWriter, request *http.Request) {
      writer.Header().Set("server", "0.01")
      h(writer, request)
   }
}
​
func withServerSetCook(h http.HandlerFunc) http.HandlerFunc {
   return func(writer http.ResponseWriter, request *http.Request) {
      cookie := http.Cookie{Name: "username", Value: "tt"}
      http.SetCookie(writer, &cookie)
      h(writer, request)
   }
}
​
func WithBasicAuth(h http.HandlerFunc) http.HandlerFunc {
   return func(writer http.ResponseWriter, request *http.Request) {
      cookie, err := request.Cookie("username")
      if err != nil || cookie.Value != "ee" {
         writer.WriteHeader(http.StatusForbidden)
         return
      }
      h(writer, request)
   }
}
​
func WithDebugLog(h http.HandlerFunc) http.HandlerFunc {
   return func(writer http.ResponseWriter, request *http.Request) {
      request.ParseForm()
      log.Println(request.Form)
      log.Println("path", request.URL.Path)
      log.Println("Host", request.URL.Host)
      log.Println(request.Form["url_long"])
      for k, v := range request.Form {
         log.Println("key:", k)
         log.Println("value:", v)
      }
      h(writer, request)
   }
}
​
func hello(w http.ResponseWriter, r *http.Request) {
   log.Printf("Recieved Request %s from %s\n", r.URL.Path, r.RemoteAddr)
   fmt.Fprintf(w, "Hello, World! "+r.URL.Path)
}
​
func main() {
   http.HandleFunc("/hello/v1", WithServerHeader(hello))
   http.HandleFunc("/hello/v2", withServerSetCook(hello))
   http.HandleFunc("/hello/v3", WithBasicAuth(hello))
   http.HandleFunc("/hello/v4", WithDebugLog(hello))
   err := http.ListenAndServe(":8080", nil)
   if err != nil {
      log.Fatal("ListenAndServe: ", err)
   }
}

1. 例子中 WithServerHeader，withServerSetCook，WithBasicAuth， WithDebugLog 就是一个装饰器，它传入一个 http.HandlerFunc 就是一个改写版本。而我们的业务hello不用修改任何功能，可以呈现出一些新的功能，很多人把这种模式称为middleware ,我更喜欢称为装饰器

三、多个装饰器Pipeline，也是options 模式

type googleSlide struct {
   sreSlide *list.List
   interval int64
   mutex    sync.Mutex
   k        int64
}
 
type slideVal struct {
   time   int64
   req    int64
   accept int64
}
 
type SlideValOptions func(val *slideVal)
 
func NewSlideval(options ...SlideValOptions) *slideVal {
   t := &slideVal{
      time: time.Now().UnixNano(),
   }
   for _, option := range options {
      option(t)
   }
   return t
}
 
func WithReqOption(req int64) SlideValOptions {
   return func(val *slideVal) {
      val.req = req
   }
}
 
func WithAcceptReqOption(accept int64) SlideValOptions {
   return func(val *slideVal) {
      val.accept = accept
   }
}
 
func NewGoogleSlide(interval time.Duration, k int64) *googleSlide {
   return &googleSlide{
      sreSlide: list.New(),
      interval: interval.Nanoseconds(),
      k:        k,
   }
}
 
func (g *googleSlide) Sre() grpc.UnaryClientInterceptor {
	return func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
		g.mutex.Lock()
		now := time.Now().UnixNano()
		front := g.sreSlide.Front()
		for front != nil && front.Value.(*slideVal).time+g.interval < now {
			g.sreSlide.Remove(front)
			front = g.sreSlide.Front()
		}
		var r, accept int64
		front = g.sreSlide.Front()
		for front != nil {
			t := front.Value.(*slideVal)
			r += t.req
			accept += t.accept
			front = front.Next()
		}
		tail := (float64(r) - float64(g.k*accept)) / (float64(r) + 1)
		if tail > 0 {
			g.mutex.Unlock()
			return errors.New("request is fail")
		}
		g.sreSlide.PushBack(NewSlideval(WithReqOption(1)))
		err := invoker(ctx, method, req, req, cc, opts...)
		if err == nil {
			g.sreSlide.PushBack(NewSlideval(WithAcceptReqOption(1)))
		}
		g.mutex.Unlock()
		return err
	}
}

这个代码是我在SRE 熔断器写的代码，现在重新拿出来，是因为具有代表性 。NewSlideval 可以支持多个装饰器，遍历装饰器，就可以得倒我们想要的功能，只要我们去实现这个装饰器。这样的代码，在golang 是常用的，在初始化配置函数经常用