(译)Go并发模式——Context

func Background() Context (1)

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) (1)

type CancelFunc func() (2)

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) (3)

func WithValue(parent Context, key interface{}, val interface{}) Context (1)

func handleSearch(w http.ResponseWriter, req *http.Request) {
    var (
        ctx    context.Context (1)
        cancel context.CancelFunc
    )
    timeout, err := time.ParseDuration(req.FormValue("timeout"))
    if err == nil {
        ctx, cancel = context.WithTimeout(context.Background(), timeout) (2)
    } else {
        ctx, cancel = context.WithCancel(context.Background())
    }
    defer cancel() (3)

    // 获取请求参数
    query := req.FormValue("q")
    if query == "" {
        http.Error(w, "no query", http.StatusBadRequest)
        return
    }

    // 获取ip地址
    userIP, err := userip.FromRequest(req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    // 存储ip地址到 ctx
    ctx = userip.NewContext(ctx, userIP)

    // 调用google搜索方法并返回结果
    start := time.Now()
    results, err := google.Search(ctx, query)
    elapsed := time.Since(start)

    if err := resultsTemplate.Execute(w, struct {
        Results          google.Results
        Timeout, Elapsed time.Duration
    }{
        Results: results,
        Timeout: timeout,
        Elapsed: elapsed,
    }); err != nil {
        log.Print(err)
        return
    }

// 为了避免key冲突而定义的非导出类型
type key int

// userIPkey 存储userIP到Context的key，它的值这里随意设定为0，
// 也可以为其他值，如果本包还有其他存储到Context的key，可以更改其int值
const userIPKey key = 0

func FromRequest(req *http.Request) (net.IP, error) {
    ip, _, err := net.SplitHostPort(req.RemoteAddr) (1)
    if err != nil {
        return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
    }
    userIP := net.ParseIP(ip) (2)
    if userIP == nil {
        return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
    }
    return userIP, nil
}

func NewContext(ctx context.Context, userIP net.IP) context.Context {
    return context.WithValue(ctx, userIPKey, userIP)
}

func FromContext(ctx context.Context) (net.IP, bool) {
    // 如果没有key对应的value，则 ctx.Value 为nil，此时ok为false，表示未获取到值
    userIP, ok := ctx.Value(userIPKey).(net.IP)
    return userIP, ok
}

func Search(ctx context.Context, query string) (Results, error) {
    // 准备google搜索api请求
    req, err := http.NewRequest("GET", "https://ajax.googleapis.com/ajax/services/search/web?v=1.0", nil)
    if err != nil {
        return nil, err
    }
    q := req.URL.Query()
    q.Set("q", query)

    // 如果ctx中存储有用的ip，则将ip传递给google服务器，Google APIs使用用户ip来区分服务初始请求。
    if userIP, ok := userip.FromContext(ctx); ok {
        q.Set("userip", userIP.String())
    }
    req.URL.RawQuery = q.Encode()

    var results Results
    // 传入一个闭包函数，接收响应和请求错误
    err = httpDo(ctx, req, func(resp *http.Response, err error) error {
        if err != nil {
            return err
        }
        defer resp.Body.Close()

        // 解析JSON结果
        // 详见：https://developers.google.com/web-search/docs/#fonje
        var data struct {
            ResponseData struct {
                Results []struct {
                    TitleNoFormatting string
                    URL               string
                }
            }
        }
        if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
            return err
        }
        for _, res := range data.ResponseData.Results {
            results = append(results, Result{Title: res.TitleNoFormatting, URL: res.URL})
        }
        return nil
    })
    // httpDo 等待闭包函数执行完成并返回, 然后可以安全的读取results
    return results, err

func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {
    c := make(chan error, 1)
    req = req.WithContext(ctx) (1)
    go func() {
        c <- f(http.DefaultClient.Do(req)) (2)
    }()
    select {
    case <-ctx.Done(): (3)
        <-c (4)
        return ctx.Err()
    case err := <-c: (5)
        return err
    }
}