转 GO接收GET/POST参数以及发送GET/POST请求

GO接收GET/POST参数以及发送GET/POST请求
go作为21世纪的新C语言，还是应该学习一下的，本文主要介绍net/http包相关用法

GO发送HTTP请求
发送GET请求
直接放代码

var client = http.Client{
	Timeout: 10 * time.Second,
}

func HttpGetRequest(url string, result interface{}) error {
	resp, err := client.Get(url)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	decoder := json.NewDecoder(resp.Body)
	err = decoder.Decode(&result)

	return err
}

get其实可以直接通过自带的http.Get()就可以发送请求，但还是建议用client方法吧
Get方式简介：数据通过URL发送，因此无安全性，且传输数据受URL最大长度影响
发送POST请求
post分为postfrom和postjson

var client = http.Client{
	Timeout: 10 * time.Second,
}

func HttpPostJson(url string, data interface{}, result interface{}, header map[string]string) error {
	buf := bytes.NewBuffer(nil)
	encoder := json.NewEncoder(buf)
	if err := encoder.Encode(data); err != nil {
		return err
	}

	request, err := http.NewRequest(http.MethodPost, url, buf)
	if err != nil {
		return err
	}

	request.Header.Add("Content-Type", "application/json")
	if header != nil {
		for k, v := range header {
			request.Header.Add(k, v)
		}
	}

	response, err := client.Do(request)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	decoder := json.NewDecoder(response.Body)
	if err = decoder.Decode(&result); err != nil {
		return err
	}

	return nil
}

func HttpPostForm(posturl string, data url.Values, result interface{}, host string) error {
	request, err := http.NewRequest(http.MethodPost, posturl, strings.NewReader(data.Encode()))
	if err != nil {
		return err
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	//request.Host = host

	resp, err := client.Do(request)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	decoder := json.NewDecoder(resp.Body)
	if err = decoder.Decode(&result); err != nil {
		return err
	}

	return nil
}

其实接口交互还是建议post方式，安全可靠，传输的数据也比较大
接收GET请求

//Get get请求url参数
func Get(req *http.Request) map[string]string {
	var result = make(map[string]string)
	keys := req.URL.Query()
	for k, v := range keys {
		result[k] = v[0]
	}

	return result
}

需要注意的是，这里的req.URL.Query()返回的是数组，因为go可以接收id=1&id=2这样形式的参数并放到同一个key下（但实际上应该没人这么传吧= =）
接收POST请求

//PostForm 获取postform形式的参数
func PostForm(req *http.Request) map[string]string {
	//body, _ := ioutil.ReadAll(req.Body)
	var result = make(map[string]string)
	req.ParseForm()
	for k, v := range req.PostForm {
		if len(v) < 1 {
			continue
		}

		result[k] = v[0]
	}

	return result
}

//PostJson 获取post json参数
func PostJson(req *http.Request, obj interface{}) error {
	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		return err
	}

	err = json.Unmarshal(body, obj)
	if err != nil {
		return err
	}

	return nil
}

这里也是两种方式
统一请求发送
考虑到go发送get和post请求需要三种形式，调用起来比较麻烦，所以做了个封装，大家看看即可0.0

var client = &http.Client{
	Timeout: 10 * time.Second,
}

// 请求时的可选项
type RequestOption struct {
	ReqBodyContent string
	Header         map[string]string // 自定义header
	Cookie         []http.Cookie     // 自定义cookie
}

// DoRequest support get/post/put
// rspObj can be obj
func DoRequest(method, reqUrl string, rspObj interface{}, option RequestOption) error {
	start := time.Now()
	rsp := new(http.Response)

	var err error
	// retry
	var rspBody []byte
	for i := 0; i <= retryTime; i++ {
		// make req
		req, reqErr := MakeRequest(method, reqUrl, option)
		if reqErr != nil {
			return fmt.Errorf("MakeRequest(%v,%v,%v) err:%s", method, reqUrl, option, reqErr.Error())
		}

		rsp, err = client.Do(req)
		if err != nil {
			err = fmt.Errorf("client.Do(req) err:%s", err.Error())
			continue
		}

		rspBody, err = ioutil.ReadAll(rsp.Body)
		if err != nil {
			err = fmt.Errorf("ioutil.ReadAll(rsp.Body) err:%s", err.Error())
			continue
		}

		// 这里可能网络异常导致未能正确返回json数据
		err = json.Unmarshal(rspBody, &rspObj)
		if err != nil {
			err = fmt.Errorf("json.Unmarshal(string(%s), &obj) err:%s", string(rspBody), err.Error())
			continue
		}

		break
	}

	if err != nil {
		return err
	}

	defer rsp.Body.Close()
	return nil
}

// MakeRequest 构造http请求
func MakeRequest(method, reqUrl string, option RequestOption) (*http.Request, error) {
	req := new(http.Request)
	var err error

	// new request
	switch strings.ToLower(method) {
	case "get":
		req, err = http.NewRequest(http.MethodGet, reqUrl, strings.NewReader(option.ReqBodyContent))
	case "post", "post_form", "post_json":
		req, err = http.NewRequest(http.MethodPost, reqUrl, strings.NewReader(option.ReqBodyContent))
	case "put":
		req, err = http.NewRequest(http.MethodPut, reqUrl, strings.NewReader(option.ReqBodyContent))
	default:
		req, err = http.NewRequest(http.MethodGet, reqUrl, strings.NewReader(option.ReqBodyContent))
	}

	if err != nil {
		return nil, fmt.Errorf("http.NewRequest(%v,%v,reader) err:%s", method, reqUrl, err.Error())
	}

	// set Content-Type
	switch strings.ToLower(method) {
	case "post", "post_form":
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	case "post_json":
		req.Header.Set("Content-Type", "application/json")
	}

	// add default host if not set
	if option.Header == nil || option.Header["host"] == "" {
		urlInfo, _ := url.Parse(reqUrl)
        host := urlInfo.Host
        if strings.Contains(urlInfo.Host, ":") {
           hostInfo := strings.Split(host, ":")
		   if len(hostInfo) > 0 {
               host = hostInfo[0]
           }
        }

        req.Host = host
	}

	for k, v := range option.Header {
		if strings.ToLower(k) == "host" {
			req.Host = v
		} else {
			req.Header.Set(k, v)
		}
	}

	// cookie
	for _, v := range option.Cookie {
		req.AddCookie(&v)
	}

	return req, nil
}

————————————————
版权声明：本文为CSDN博主「_xiaoxiao程序员」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34694342/article/details/103192894