设计模式： 好莱坞风格与依赖注入

type E1 struct {
    willCall func()
}

func (e *E1) Reg(f func()) {
    e.willCall = f // 框架在合适的时候注入e1的依赖
}

func (e *E1) Run(){
    e.willCall() // e调用的是抽象的函数，而非具体
}

package main

import (
    "fmt"
    "strings"
)

var originData = `The target field within a path is name for the target. This field MUST only ever be present on prefix paths in the corresponding request and response messages. This field is optional for clients. When set in the prefix in a request, GetRequest, SetRequest or SubscribeRequest, the field MUST be reflected in the prefix of the corresponding GetResponse, SetResponse or SubscribeResponse by a server. This field is used to allow a name to be associated with all the data for a given stream if requested by a client. If a client does not set this field in the prefix of a request, it MUST NOT be set in the prefix of the corresponding response messages. The value for target is tied to the context of a client RPC and not persisted or shared among multiple clients.`

var originStopwords = []string{"be", "is", "by", "and", "in", "of", "are", "to", "if", "on", "for", "the"}

type FrameWork struct {
    LoadHandlers []func()
    WorkHandlers []func()
    EndHandlers  []func()
}

func (f *FrameWork) Reg(fn func(), ttype string) {
    switch ttype {
    case "load":
        f.LoadHandlers = append(f.LoadHandlers, fn)
    case "work":
        f.WorkHandlers = append(f.WorkHandlers, fn)
    case "end":
        f.EndHandlers = append(f.EndHandlers, fn)
    }
}

func (f *FrameWork) Run() {
    for _, h := range f.LoadHandlers {
        h()
    }
    for _, h := range f.WorkHandlers {
        h()
    }
    for _, h := range f.EndHandlers {
        h()
    }
}

type StopWordFilter struct {
    stopwords []string
}

func (s *StopWordFilter) Load() {
    s.stopwords = originStopwords
}

func (s *StopWordFilter) IsStopWord(w string) bool {
    for _, tp := range s.stopwords {
        if tp == w {
            return true
        }
    }
    return false
}

type DataHandler struct {
    filters     []func(w string) bool
    wordHandler []func(w string)
    data        []string
}

func (d *DataHandler) RegFilter(f func(w string) bool) {
    d.filters = append(d.filters, f)
}
func (d *DataHandler) RegWordHandler(f func(w string)) {
    d.wordHandler = append(d.wordHandler, f)
}

func (d *DataHandler) Load() {
    tpdata := strings.Split(originData, " ")
    for _, word := range tpdata {
        word = strings.Replace(word, ".", "", -1)
        word = strings.Replace(word, "'", "", -1)
        word = strings.Replace(word, ",", "", -1)
        word = strings.Replace(word, " ", "", -1)
        word = strings.ToLower(word)
        d.data = append(d.data, word)
    }
}

func (d *DataHandler) Run() {
    isFilter := func(word string) bool {
        for _, filter := range d.filters {
            if filter(word) == true {
                return true
            }
        }
        return false
    }
    for _, word := range d.data {
        if isFilter(word) == false {
            for _, h := range d.wordHandler {
                h(word)
            }
        }
    }
}

type WordsCounter struct {
    counts map[string]int
}

func (w *WordsCounter) Load() {
    w.counts = make(map[string]int)

}

func (w *WordsCounter) Count(word string) {
    _, ok := w.counts[word]
    if ok {
        w.counts[word]++
    } else {
        w.counts[word] = 1
    }
}

func (w *WordsCounter) PrintAll() {
    for key := range w.counts {
        fmt.Printf("word:%v, count:%v\n", key, w.counts[key])
    }
}

func main() {
    framework := new(FrameWork)
    dataHandler := new(DataHandler)
    stopwordsFilter := new(StopWordFilter)
    counter := new(WordsCounter)

    framework.Reg(dataHandler.Load, "load")
    framework.Reg(stopwordsFilter.Load, "load")
    framework.Reg(counter.Load, "load")

    dataHandler.RegFilter(stopwordsFilter.IsStopWord)
    dataHandler.RegWordHandler(counter.Count)

    framework.Reg(dataHandler.Run, "work")
    framework.Reg(counter.PrintAll, "end")

    framework.Run()
}