使用net/http实现基本的https 服务端/客户端

TLS协议简介：

安全传输协议（Transport Layer Security）简称TLS协议，其是SSL协议的升级版，用于实现两个程序之间的加密通信：

Golang的net/http包

golang的net/http包提供了网络访问相关的api，可实现tcp、udp以及http的访问：

listen, err := net.Listen("tcp", "127.0.0.1:16666")

conn, err := net.Dial("tcp", "127.0.0.1:16666")

// 单独写回调函数
http.HandleFunc("/go", myHandler)
//http.HandleFunc("/ungo",myHandler2 )
// addr：监听的地址
// handler：回调函数
http.ListenAndServe("127.0.0.1:8000", nil)

使用net/http实现基本的https 服务端/客户端

申请tls证书

我们实现一个接收[]string的数组，然后判断是否已经接收过，最后返回[]bool，下面直接上代码：

服务端

func RunServer()  {
	fmt.Println("Run server...")
	listen()
}

func listen()  {
	http.HandleFunc("/hello",handler)
	err:=http.ListenAndServeTLS(":16666","ssl.crt","ssl.key", nil)
	if err!=nil{
		fmt.Println("ListenAndServe:",err)
	}
}

func handler(w http.ResponseWriter, r *http.Request)  {
	fmt.Println("Server starting handle...")
	buf := make([]byte, 1024)
	var recvStr string
	for{
		n,err:=r.Body.Read(buf)
		if err != nil && err != io.EOF {
			fmt.Println(err)
			return
		} else {
			recvStr += string(buf[:n])
			break
		}
	}
	var result []bool
	if len(recvStr)>0{
		datas:=strings.Split(recvStr,"\n")
		result=make([]bool,len(datas))
		lock.Lock()
		for i,v:=range datas{
			if _,ok:=ReceivedDatas[v];ok{
				result[i]=true
			}else {
				result[i]=false
				ReceivedDatas[v]=true
			}
		}
		lock.Unlock()
	}else {
		result=make([]bool,0)
	}
	w.Header().Set("Content-Type","text/plain")
	resultJson, err :=json.Marshal(result)
	if err!=nil{
		w.Write([]byte("500"))
	}
	w.Write(resultJson)
}

客户端

func Client(input []string) ([]bool,error) {
	//设置tls配置信息
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	transData:=strings.Join(input,"\n")
	client := &http.Client{Transport: tr}
	res,err:=client.Post("https://127.0.0.1:16666/hello","text/plain",strings.NewReader(transData))
	if err!=nil{
		return nil,err
	}
	defer res.Body.Close()
	if res.StatusCode!=200{
		return nil,errors.New("500")
	}
	body,err:=ioutil.ReadAll(res.Body)
	if err!=nil{
		return nil,err
	}
	if string(body)=="500"{
		return nil,errors.New("500")
	}
	var result []bool
	err=json.Unmarshal(body,&result)
	if err!=nil{
		return nil,err
	}
	return result,err
}

全局变量：

var ReceivedDatas map[string]bool
var lock sync.Mutex

func init()  {
	ReceivedDatas=make(map[string]bool,0)
}

最后我们来测试一下：

新建一个测试文件，代码如下：

func TestClient(t *testing.T) {
	go RunServer()
	inputs:=[]string{"hi","hello"}
	result,err:=Client(inputs)
	if err!=nil{
		t.Fatal(err)
	}
	if len(inputs)!=len(result){
		t.Fatal("1-return data num error")
	}

	if result[0] {
		t.Fatal("1-1failed")
	}
	if result[1] {
		t.Fatal("1-2failed")
	}
	//到这里说明第一个已经通过
	t.Log(result)

	names:=[]string{"曹操","孙权","孙权","hello"}
	resultNames,err:=Client(names)
	if err!=nil{
		t.Fatal(err)
	}
	if len(names)!=len(resultNames){
		t.Fatal("2-return data num error")
	}
	if resultNames[0] {
		t.Fatal("2-1failed")
	}
	if resultNames[1] {
		t.Fatal("2-2failed")
	}
	if !resultNames[2] {
		t.Fatal("2-3failed")
	}
	if !resultNames[3] {
		t.Fatal("2-4failed")
	}
	//到这里说明第二个已经通过
	t.Log(resultNames)
}