go语音 post和get请求

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)



func main(){
    uI := httpPost("http:xxxxxx")
    fmt.Println(uI)
    user :=userInfo{}
    httpGet("http:xxxxxx?a=0&b=1&c=2",&user)
    fmt.Println(user)
}



type userInfo struct {
    Code int `json:"code"`
    Data interface{} `json:"data"`
    Msg string `json:"msg"`
}

/*httpPost请求，获取userInfo,并将响应数据json解析定义的结构*/
func httpPost(url string) (uI userInfo) {
    data := map[string]interface{}{
        "FirstName":"Jan",
        "Sex":18,
    }
    stu,_ := json.Marshal(&data)
    reader := bytes.NewReader(stu)
    request,_ := http.NewRequest("POST", url, reader)
    request.Header.Set("Content-Type", "application/json")
    client:=&http.Client{}
    response,_ := client.Do(request)
    defer response.Body.Close()
    body,_ := ioutil.ReadAll(response.Body)
    //已知结构解析
    _ = json.Unmarshal(body, &uI)
    /*//未知结构解析
    var uI interface{}
    _ = json.Unmarshal(body, &uI)*/
    return  uI
}
/*httpGet请求,并将响应数据json解析定义的结构*/
func httpGet(url string,data interface{}) interface{} {
    resp, err := http.Get(url)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    err = json.NewDecoder(resp.Body).Decode(&data)
    return  data
}

//get 2

 

func HttpGet(url string) string {
   resp, err := http.DefaultClient.Get(url)  
   if err != nil {
      panic(err)     
   }
   defer resp.Body.Close()
   body, _ := ioutil.ReadAll(resp.Body)
   return string(body)
}

//get  3

func httpClient(url string) string {
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        panic(err)
    }
    client := new(http.Client)
    response, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    body, _ := ioutil.ReadAll(response.Body)
    return string(body)
}

//get 4

 

const ProxyServer = "t.16yun.cn:31111"

type ProxyAuth struct {
    Username string
    Password string
}

func (p ProxyAuth) ProxyClient() http.Client {

    var proxyURL *url.URL
    if p.Username != ""&& p.Password!="" {
        proxyURL, _ = url.Parse("http://" + p.Username + ":" + p.Password + "@" + ProxyServer)
    }else{
        proxyURL, _ = url.Parse("http://" + ProxyServer)
    }
    return http.Client{Transport: &http.Transport{Proxy:http.ProxyURL(proxyURL)}}
}
func httpProxyGet(targetURI string) string {
    // 初始化 proxy http client
    client := ProxyAuth{"username",  "password"}.ProxyClient()
    request, _ := http.NewRequest("GET", targetURI, bytes.NewBuffer([] byte(``)))

    // 设置Proxy-Tunnel
    // rand.Seed(time.Now().UnixNano())
    // tunnel := rand.Intn(10000)
    // request.Header.Set("Proxy-Tunnel", strconv.Itoa(tunnel) )


    resp, err := client.Do(request)

    if err != nil {
        return ""
    } else {

        defer resp.Body.Close()
        body, _ := ioutil.ReadAll(resp.Body)
        return string(body)
    }
}

 

func GET(url string, reply interface{}) (err error) {
    var (
        v        []byte
        response *http.Response
    )

    response, err = http.Get(url)

    if err != nil {
        return
    }

    if response == nil {
        return
    }

    defer response.Body.Close()

    if v, err = ioutil.ReadAll(response.Body); err != nil {
        return
    }

    return json.Unmarshal(v, reply)
}

func HttpsGET(url string, reply interface{}) (err error) {
    var (
        v        []byte
        response *http.Response
    )
    //定义TLSClientConfig，忽略证书校验
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr}
    response, err = client.Get(url)

    //response, err = http.Get(url)

    if err != nil {
        return
    }

    if response == nil {
        return
    }

    defer response.Body.Close()

    if v, err = ioutil.ReadAll(response.Body); err != nil {
        return
    }
    log.Printf("[GET]%#v", string(v))

    return json.Unmarshal(v, reply)
}

//使用代理服务的HTTP Get方法
func ProxyGet(proxy func(_ *http.Request) (*url.URL, error), url string) (resp *http.Response, err error) {
    transport := &http.Transport{Proxy: proxy, TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
    client := &http.Client{Transport: transport, Timeout: 3 * time.Second}

    return client.Get(url)

}

func ProxyHttpsGet(proxy func(_ *http.Request) (*url.URL, error), url string, reply interface{}) (err error) {
    var (
        v        []byte
        response *http.Response
    )

    tr := &http.Transport{
        Proxy:           proxy,
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr, Timeout: 3 * time.Second}
    response, err = client.Get(url)

    //response, err = http.Get(url)

    if err != nil {
        return
    }

    if response == nil {
        return
    }

    defer response.Body.Close()

    if v, err = ioutil.ReadAll(response.Body); err != nil {
        return
    }
    log.Printf("[GET]%#v", string(v))

    return json.Unmarshal(v, reply)
}