网络编程(tcp,udp,http)

1.Go语言实现TCP通信

一个TCP服务端可以同时连接很多个客户端，例如世界各地的用户使用自己电脑上的浏览器访问淘宝网。因为Go语言中创建多个goroutine实现并发非常方便和高效，所以我们可以每建立一次链接就创建一个goroutine去处理。

TCP服务端程序的处理流程：

1. 监听端口
2. 接收客户端请求建立链接
3. 创建goroutine处理链接。

我们使用Go语言的net包实现的TCP服务端代码如下：

func process (coon net.Conn){
   for  {
      //3.与客户端通信
      var tmp [128]byte
      n,err :=coon.Read(tmp[:])
      if err != nil {
         fmt.Println("Read Form coon ,err: ",err)
         return
      }
      fmt.Println(string(tmp[:n]))
   }
}

func main(){
   //1.本地端口启动服务
   listener,err :=net.Listen("tcp","127.0.0.1:20000")
   if err != nil {
      fmt.Println("start server failed ,err: ",err)
      return
   }
   //2.等待别人来跟我建立链接
   for   {
      coon ,err := listener.Accept()
      if err != nil {
         fmt.Println("listener.Accept() ,err: ",err)
         return
      }
      go process(coon)
   }

}

一个TCP客户端进行TCP通信的流程如下：

1. 建立与服务端的链接
2. 进行数据收发
3. 关闭链接

使用Go语言的net包实现的TCP客户端代码如下：

func main()  {
   //1、与sever端建立链接
   coon ,err := net.Dial("tcp","127.0.0.1:20000")
   if err != nil {
      fmt.Println("dial 127.0.0.1:20000  failed ,err: ",err)
      return
   }
   //2.发送数据，监听控制台输入，没有用fmt.Scanln,因为不支持空格
   for   {
      fmt.Println("请说话：")
      reader := bufio.NewReader(os.Stdin)
      content ,_:=reader.ReadString('\n')
      msg := strings.TrimSpace(content)
      if msg == "exit" {
         break
      }
      _,err :=coon.Write([]byte(msg))
      if err != nil {
         fmt.Println("客户端发送数据  failed ,err: ",err)
         return
      }

   }
   error := coon.Close()
   if error != nil {
      fmt.Println("coon.Close()failed ,err: ",err)
      return
   }
}

2.Go语言实现UDP通信

UDP协议

UDP协议（User Datagram Protocol）中文名称是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议，不需要建立连接就能直接进行数据发送和接收，属于不可靠的、没有时序的通信，但是UDP协议的实时性比较好，通常用于视频直播相关领域。

UDP服务端

func main()  {
	listen, err:= net.ListenUDP("udp",&net.UDPAddr{
		 IP:   net.IPv4(127,0,0,1),
		 Port: 40000,
	 })
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	//接受对方回传消息
	var data [1024]byte
	for {
		n,udpAddr ,err := listen.ReadFromUDP(data[:])        //ReadFromUDP只接受byte切片参数
		if err != nil {
			fmt.Println("read udp failed, err:", err)
			continue
		}
		fmt.Printf("data:%v addr:%v count:%v\n", string(data[:n]), udpAddr, n)
		
		//addr 就知道了是谁发过来的数据，回复消息
		msg := strings.ToUpper(string(data[:n]))
		_,err = listen.WriteToUDP([]byte(msg),udpAddr)
		if err != nil {
			fmt.Println("write to udp failed, err:", err)
			continue
		}
	}
}

net.ListenUDP 参数，传“udp” ， 和UDPAddr的一个指针

UDPAddr结构体如下，IP类型我们通过net.IPv4()获取。

UDP客户端

func main()  {
   udpClientCoon, err :=net.DialUDP("udp",nil,&net.UDPAddr{
      IP:   net.IPv4(127,0,0,1),
      Port: 40000,
   })
   if err != nil {
      fmt.Println("连接服务端失败，err:", err)
      return
   }
   defer udpClientCoon.Close()
   reader :=bufio.NewReader(os.Stdin)
   var reply [1024]byte
   for  {
      fmt.Println("请输入内容：")
      msg, _ :=reader.ReadString('\n')
      udpClientCoon.Write([]byte(msg))

      //收到server端回复的消息
      n, _ ,err :=udpClientCoon.ReadFromUDP(reply[:])
      if err != nil {
         fmt.Println("接收数据失败，err:", err)
         return
      }
      fmt.Println("收到sever回复的消息：",string(reply[:n]))
   }
}

net.DialUDP的（）得到对方的coon, 将来回复消息，直接coon,Write()即可，不需要和sever端一样需要传addr地址。

3. net/http

Go语言内置的net/http包提供了HTTP客户端和服务端的实现。

1.htttp服务端

// 必须符合 http.HandleFunc 所要求的函数参数。
func HandleIndexPage(w http.ResponseWriter , r *http.Request)  {
   context,err  := ioutil.ReadFile("D:/go/path/src/test/test/net/http/sever/index.html")
   if err != nil {
      fmt.Printf("打开文件失败, err:%v\n", err)
      return
   }
   w.Write(context)
}

func main()  {
   http.HandleFunc("/",HandleIndexPage)                   //访问根目录调用的函数
   err := http.ListenAndServe("127.0.0.1:9091",nil)
   if err != nil {
      fmt.Printf("http server failed, err:%v\n", err)
      return
   }
}

ListenAndServe使用指定的监听地址和处理器启动一个HTTP服务端。处理器参数通常是nil，这表示采用包变量DefaultServeMux作为处理器。

http.HandleFunc（）第一个参数为路径，第二个参数为处理函数名，（对参数有要求)

2.http客户端（带参数）

package main

import (
   "fmt"
   "io/ioutil"
   "net/http"
)

func main() {
     resp ,err := http.Get("http://127.0.0.1:9091/?name=guo&age=25")  带参数的GET请求
    if err != nil {
      fmt.Printf("get failed, err:%v\n", err)
      return
   }
   defer resp.Body.Close()
   content , err := ioutil.ReadAll(resp.Body)
   if err != nil {
      fmt.Printf("read from resp.Body failed, err:%v\n", err)
      return
   }
   fmt.Println(string(content))
}

sever端

func HandleIndexPage2(w http.ResponseWriter , r *http.Request)  {
   queryParam :=r.URL.Query()                        解析参数
   name := queryParam.Get("name")               
   age  := queryParam.Get("age")                
   fmt.Println("name：",name)  				    //name： guo
   fmt.Println("age:",age)                      //age: 25
   fmt.Println(r.URL) 						    ///?name=guo&age=25
   fmt.Println(r.Method)						//GET
   fmt.Println(ioutil.ReadAll(r.Body))			//GET     GET请求在head里，Body里没东西
   w.Write([]byte("hello"))

}

func main()  {
   http.HandleFunc("/",HandleIndexPage1)
   err := http.ListenAndServe("127.0.0.1:9091",nil)
   if err != nil {
      fmt.Printf("http server failed, err:%v\n", err)
      return
   }
}