golang责任链模式

编写递归代码的关键是，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

典型的实现是chain模式

package cron

import (
   "fmt"
   "runtime"
   "sync"
   "time"
)

// JobWrapper decorates the given Job with some behavior.
// JobWrapper 用一些行为装饰给定的 Job。
type JobWrapper func(Job) Job

// Chain is a sequence of JobWrappers that decorates submitted jobs with
// cross-cutting behaviors like logging or synchronization.
// Chain 是一系列 JobWrappers，用于装饰提交的job
type Chain struct {
   wrappers []JobWrapper
}

// NewChain returns a Chain consisting of the given JobWrappers.
func NewChain(c ...JobWrapper) Chain {
   return Chain{c}
}

// Then decorates the given job with all JobWrappers in the chain.
//
// This:
//
// NewChain(m1, m2, m3).Then(job)
//
// is equivalent to:
//
// m1(m2(m3(job)))
func (c Chain) Then(j Job) Job {
   for i := range c.wrappers {
      j = c.wrappers[len(c.wrappers)-i-1](j)
   }
   return j
}

// Recover panics in wrapped jobs and log them with the provided logger.
// 恢复包装作业中的panic并使用提供的日志记录它们。
func Recover(logger Logger) JobWrapper {
   return func(j Job) Job {
      return FuncJob(func() {
         defer func() {
            if r := recover(); r != nil {
               const size = 64 << 10
               buf := make([]byte, size)
               buf = buf[:runtime.Stack(buf, false)]
               err, ok := r.(error)
               if !ok {
                  err = fmt.Errorf("%v", r)
               }
               logger.Error(err, "panic", "stack", "...\n"+string(buf))
            }
         }()
         j.Run()
      })
   }
}

// DelayIfStillRunning serializes jobs, delaying subsequent runs until the
// previous one is complete. Jobs running after a delay of more than a minute
// have the delay logged at Info.
// DelayIfStillRunning 序列化作业，延迟后续运行直到 将延迟记录在 Info.
//
// 延迟超过一分钟后运行的作业， 将延迟记录在 Info.
func DelayIfStillRunning(logger Logger) JobWrapper {
   return func(j Job) Job {
      var mu sync.Mutex
      return FuncJob(func() {
         start := time.Now()
         mu.Lock()
         defer mu.Unlock()
         if dur := time.Since(start); dur > time.Minute {
            logger.Info("delay", "duration", dur)
         }
         j.Run()
      })
   }
}

// SkipIfStillRunning skips an invocation of the Job if a previous invocation is
// still running. It logs skips to the given logger at Info level.
// 跳过，如果还在运行
func SkipIfStillRunning(logger Logger) JobWrapper {
   return func(j Job) Job {
      var ch = make(chan struct{}, 1)
      ch <- struct{}{}
      return FuncJob(func() {
         select {
         case v := <-ch:
            defer func() { ch <- v }()
            j.Run()
         default:
            logger.Info("skip")
         }
      })
   }
}

实际例子1

func TestChain(t *testing.T) {
   var nums []int
   var (
      append1 = appendingWrapper(&nums, 1)
      append2 = appendingWrapper(&nums, 2)
      append3 = appendingWrapper(&nums, 3)
      append4 = appendingJob(&nums, 4)
   )
   NewChain(append1, append2, append3).Then(append4).Run()
   if !reflect.DeepEqual(nums, []int{1, 2, 3, 4}) {
      t.Error("unexpected order of calls:", nums)
   }
}

实际例子2

func TestChainDelayIfStillRunning1(t *testing.T) {
   var j countJob
   j.delay = 2 * time.Second
   wrappedJob := NewChain(DelayIfStillRunning(DiscardLogger)).Then(&j)
   go wrappedJob.Run()
   time.Sleep(2 * time.Millisecond) // Give the job 2ms to complete.
   if c := j.Done(); c != 1 {
      t.Errorf("expected job run once, immediately, got %d", c)
   }
}