Go批量接口编写示例

// 入参
type Reqs struct {
	Reqs map[int64]*req
}

// 出参
type Resps struct {
	Resps map[int64]*resp
}

type Handler struct {
	req *Reqs
}

部分失败->整体不失败

func (h *Handler) Handles() (*Resps, error) {
	var (
		concurrentResult = sync.Map{}
		wg               = sync.WaitGroup{}
	)

	// concurrent execute the create record handler
	for key, req := range h.req.Reqs() {
		wg.Add(1)
		go func(key int64, req *req) {
			defer func() {
				wg.Done()
				if err := recover(); err != nil {
					resp := 异常resp
					concurrentResult.Store(key, resp)
				}
			}()

			// save result
			resp := &resp{}
			resp,err := h.Handle(req); 
			if err != nil {
				resp = 异常resp
			
			// set result
			concurrentResult.Store(key, resp)
		}(key, req)
	}
	wg.Wait()
	
	// 并发处理完后，处理结果
	resps := map[int64]*resp{}
	// 遍历结果map,如果func
	concurrentResult.Range(func(k, v interface{}) bool {
		if v == nil {
			return true
		}

		// get
		key, ok := k.(int64)
		if !ok {
			return true
		}
		tempResp, ok := v.(*resp)
		if !ok {
			return true
		}

		resps[key] = tempResp
		return true
	})

	return &Resps{
		Resps: resps,
	}, nil
}

部分失败->整体失败

TBD