1.互联网分层模型

网络基础 - 图1

2.TCP通信

Socket是BSD UNIX的进程通信机制，通常也称作套接字，用于描述IP地址和端口，是一个通信链的句柄。
Socket可以理解为TCP/IP网络的API

TCP协议

TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议。

TCP服务端

一个TCP服务端可以同时连接很多个客户端，因为Go语言中创建多个goroutine实现并发非常方便和高效，所以我们可以每建立一次链接就创建一个goroutine去处理。
TCP服务端程序的处理流程：

监听端口
接收客户端请求建立链接

创建goroutine处理链接。 ```go func process(conn net.Conn) { defer conn.Close() for{

 reader := bufio.NewReader(conn)
 var buf [128]byte
 n, err := reader.Read(buf[:])   //读取数据
 if err != nil {
     fmt.Println("read from client failed, err:", err)
     break
 }
 str:= string(buf[:n])
 fmt.Println("收到client端发来的数据：",str)
 conn.Write([]byte("server接收消息成功"))   //发送数据

}

} func main() { listen, err := net.Listen(“tcp”, “127.0.0.1:9000”) if err != nil { fmt.Println(“listen failed,err:”,err) return } for{ conn, err := listen.Accept() //建立连接 if err != nil { fmt.Println(“accept failed, err:”, err) continue } go process(conn) // 启动一个goroutine处理连接 } }

<a name="th9tQ"></a>
## TCP客户端
一个TCP客户端进行TCP通信的流程如下：
1. 建立与服务端的链接
1. 进行数据收发
1. 关闭链接
```go
func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:9000")
    if err != nil {
        fmt.Println("err:",err)
        return
    }
    defer conn.Close()
    inputReader := bufio.NewReader(os.Stdin)
    for  {
        input, _ := inputReader.ReadString('\n')
        inputInfo := strings.TrimSpace(input)
        if strings.ToUpper(inputInfo)=="Q" {
            return
        }
        _, err := conn.Write([]byte(inputInfo))  //发送数据
        if err != nil {
            return
        }
        buf := [512]byte{}
        n, err := conn.Read(buf[:])
        if err != nil {
            fmt.Println("recv failed, err:", err)
            return
        }
        fmt.Println(string(buf[:n]))
    }
}

在client端输入任意内容回车之后就能够在server端看到client端发送的数据，从而实现TCP通信。

TCP黏包

func process(conn net.Conn)  {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    var buf [1024]byte
    for  {
        n, err := reader.Read(buf[:])
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Println("read from client failed, err:", err)
            break
        }
        str := string(buf[:n])
        fmt.Println("收到client发来的数据:",str)
    }
}
func main() {
    listen, err := net.Listen("tcp", "127.0.0.1:9080")
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    defer listen.Close()
    for  {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("accept failed, err:", err)
            continue
        }
        go process(conn)
    }
}

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:9080")
    if err != nil {
        fmt.Println("dial failed, err", err)
        return
    }
    defer conn.Close()
    for i := 0; i < 20; i++ {
        msg :=`hello,How are you???`
        conn.Write([]byte(msg))
    }
}

客户端分10次发送的数据，在服务端并没有成功的输出10次，而是多条数据粘到了一起。

3.UDP通信

UDP协议是用户数据报协议，是OSI参考模型中一种无连接的传输层协议，不需要建立连接就能直接进行数据发送和接收，属于不可靠的、没有时序的通信，但是UDP协议的实时性比较好，通常用于视频直播相关领域。

3.1UDP服务端

func main() {
    listen, err := net.ListenUDP("udp", &net.UDPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 8090,
    })
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    for  {
        var data [1024]byte
        n, addr, err := listen.ReadFromUDP(data[:])  //接收数据
        if err != nil {
            fmt.Println("read udp failed, err:", err)
            continue
        }
        fmt.Println("接收到client的消息",string(data[:n]))
        //fmt.Printf("data:%v addr:%v  count:%v\n",string(data[:n]),addr,n)
        _, err = listen.WriteToUDP([]byte("server接收数据成功"), addr)  //发送数据
        if err != nil {
            fmt.Println(err)
            continue
        }
    }
}

3.2UDP客户端

func main() {
    socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 8090,
    })
    if err != nil {
        fmt.Println("连接服务端失败，err:", err)
        return
    }
    defer socket.Close()
    sendMsg :=[]byte("Hello server!!!")
    _, err = socket.Write(sendMsg) // 发送数据
    if err != nil {
        fmt.Println("发送数据失败，err:", err)
        return
    }
    data := make([]byte,4096)
    n, addr, err := socket.ReadFromUDP(data) //接收数据
    if err != nil {
        fmt.Println("接收数据失败，err:", err)
        return
    }
    fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:n]), addr, n)
}

4.http编程

4.1HTTP协议

超文本传输协议(HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和万维网服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议
HTTP协议通常承载于TCP协议之上
4.2HTTP服务端
```go //handler函数 func myHandler(w http.ResponseWriter,r *http.Request) { fmt.Println(r.RemoteAddr,”连接成功”) fmt.Println(“methid:”,r.Method) fmt.Println(“url”,r.URL.Path) fmt.Println(“header:”,r.Header) fmt.Println(“body”,r.Body) w.Write([]byte(“HelloWorld”))

} func main() { //回调函数 http.HandleFunc(“/go”,myHandler) http.ListenAndServe(“127.0.0.1:9000”,nil) }

```go
func main() {
    resp, _ := http.Get("https://www.bilibili.com/")
    defer resp.Body.Close()
    fmt.Println(resp.Status)
    fmt.Println(resp.StatusCode)
    fmt.Println(resp.Header)
    buf := make([]byte, 1024)
    for  {
        n, err := resp.Body.Read(buf)
        if err != nil && err != io.EOF{
            fmt.Println(err)
            return
        }else {
            fmt.Println("读取完毕")
            res := buf[:n]
            fmt.Println(string(res))
            break
        }
    }
}

func main() {
    resp, _ := http.Get("https://www.bilibili.com/")
    defer resp.Body.Close()
    fmt.Println(resp.Status)
    fmt.Println(resp.StatusCode)
    fmt.Println(resp.Header)
    all, err := ioutil.ReadAll(resp.Body)
    if err != nil && err != io.EOF{
        fmt.Println(err)
        return
    }
    fmt.Println(string(all))
}

网络基础