设计模式：参与者风格

WordFrequencyController  --send--> StopWordManager --send--> WordFrequencyManager

package main

import (
    "fmt"
    "strings"
    "time"
)

func main() {

    manager := new(WordFrequencyManager)
    manager.queue = make(chan []interface{})
    manager.wordMap = make(map[string]int)
    go manager.Run()

    stopWordManager := new(StopWordManager)
    stopWordManager.queue = make(chan []interface{})
    stopWordManager.manager = manager
    stopWordManager.stopWords = []string{"be", "is", "by", "and", "in", "of", "are", "to", "if", "on", "for", "the"}
    go stopWordManager.Run()

    controller := new(WordFrequencyController)
    controller.queue = make(chan []interface{})
    controller.manager = stopWordManager
    go controller.Run()

    controller.Send([]interface{}{"send_words", originData})
    time.Sleep(time.Millisecond * 300)
    manager.Send([]interface{}{"print"})
    time.Sleep(time.Millisecond * 300)
}

type WordFrequencyController struct {
    queue   chan []interface{}
    manager *StopWordManager
}

func (w *WordFrequencyController) Send(msg []interface{}) {
    w.queue <- msg
}

func (w *WordFrequencyController) Run() {
    for msg := range w.queue {
        ttype := msg[0]
        wordsStr := msg[1].(string)
        if ttype == "send_words" {
            words := w.split(wordsStr)
            for _, word := range words {
                w.manager.Send([]interface{}{"filter", word})
            }
        }
    }
}

func (w *WordFrequencyController) split(words string) []string {
    tpdata := strings.Split(words, " ")
    ret := make([]string, 0)
    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)
        ret = append(ret, word)
    }
    return ret
}

type WordFrequencyManager struct {
    queue   chan []interface{}
    wordMap map[string]int
}

func (w *WordFrequencyManager) Send(msg []interface{}) {
    w.queue <- msg
}

func (w *WordFrequencyManager) Run() {
    for msg := range w.queue {
        ttype := msg[0]
        if ttype == "word" {
            word := msg[1].(string)
            v, ok := w.wordMap[word]
            if ok {
                w.wordMap[word] = v + 1
            } else {
                w.wordMap[word] = 1
            }
        } else if ttype == "print" {
            fmt.Println(w.wordMap)
        }
    }
}

type StopWordManager struct {
    queue     chan []interface{}
    stopWords []string
    manager   *WordFrequencyManager
}

func (s *StopWordManager) Send(msg []interface{}) {
    s.queue <- msg
}

func (s *StopWordManager) Run() {
    for msg := range s.queue {
        ttype := msg[0].(string)
        word := msg[1].(string)
        if ttype == "filter" {
            if !StrIn(word, s.stopWords) {
                s.manager.Send([]interface{}{"word", word})
            }
        }
    }
}

func StrIn(w string, l []string) bool {
    for _, item := range l {
        if w == item {
            return true
        }
    }
    return false
}

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.`