GO语言初级学习之代码案例10 （TCP并发服务器&并发

@(go语言 黑马)[GO语言]

简单版TCP服务器

• 题目：搭建一个简单版TCP服务器
• 知识点：TCP通信
• 逻辑：

_1. 创建服务器的IP+port(端口号)
_2. 创建通信socket
_3. 读写客户端数据

• 代码如下：

package main

import "fmt"

func main() {
    listener, err := net.Listen("tcp", ":8000") //创建服务器的IP+port(端口号)
    if err != nil {
        fmt.Println("Listen err:", err)
        return
    }
    defer listener.Close() //不要忘了结束关闭

    conn, err := listener.Accept() //conn是与客户端通信的socket，用于接收和发送数据
    fmt.Println("成功连接！")
    if err != nil {
        fmt.Println("Accept err:", err)
        return
    }

    //读取客户端发来的请求
    buf := make([]byte, 4096)

    n, err := conn.Read(buf)
    if n == 0 {
        return
    }
    if err != nil {
        fmt.Println("conn.Read err:", err)
        return
    }
    fmt.Println("收到客户端的请求：", string(buf[:n]))
    conn.Write([]byte(strings.ToUpper(string(buf[:n])))) //处理数据，并返回给客户端，ToUpper()是转大写的意思
}

简单版TCP客户端

• 题目：搭建一个简单版TCP客户端
• 知识点：TCP通信
• 逻辑：

_1. 与服务器建立连接
_2. 发送请求
_3. 接收客户端数据

• 代码如下：

package main

import "fmt"

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:8000")//建立连接
    if err != nil {
        fmt.Println("net.Dial err:", err)
        return
    }

    conn.Write([]byte("Are you ready?"))//发送请求

    buf := make([]byte, 4096)
    n, err01 := conn.Read(buf)//读取服务器回发的数据
    if err01 != nil {
        fmt.Println("conn.Read err:", err01)
        return
    }
    fmt.Println("读到服务器发送的数据：", string(buf[:n]))
}

并发服务器

• 题目：搭建一个：可以连接多个客户端，能够重复与每个客户端通信，并且能够识别客户端发送的exit请求的服务器
• 知识点：TCP通信，go并发
• 逻辑：

_1. 写出单个通信服务器
_2. 完善重复通信功能
_3. 完善连接多个客户端功能

• 代码如下：

package main

import "fmt"

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:8001")
    if err != nil {
        fmt.Println("net.Listen err:", err)
        return
    }
    defer listener.Close()

    for {
        fmt.Println("等待客户端连接...")
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("listener.Accept err:", err)
            return
        }
        go commu(conn)
    }
}
func commu(conn net.Conn)  {
    defer conn.Close()
    for {
        buf := make([]byte, 4096)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("conn.Read err:", err)
            return
        }
        if string(buf[:n]) == "exit\n" || string(buf[:n]) == "exit\r\n" {
            fmt.Println("客户端请求断开")
            return
        }
        if n == 0 {
            return
        }
        fmt.Println("读到客户端请求：", string(buf[:n]))

        conn.Write([]byte(strings.ToUpper(string(buf[:n]))))
    }
}

并发客户端

• 题目：搭建一个：能够不断地向服务器发送请求，每发送一次请求读取回复一次，能够判断出客户端是否关闭的客户端
• 知识点：TCP通信，go并发
• 逻辑：

_1. 写出简单版服务器
_2. 完善重复通信功能
_3. 完善识别服务器是否关闭功能

• 代码如下：

package main

import "fmt"


func main() {
    conn,err:=net.Dial("tcp","127.0.0.1:8001")
    if err != nil {
        fmt.Println("net.Dial err:", err)
        return
    }
    defer conn.Close()

    for {
        buf := make([]byte, 4096)
        n, err := os.Stdin.Read(buf)
        if err != nil {
            fmt.Println("os.Stdin.Read err:", err)
            return
        }

        conn.Write([]byte(string(buf[:n])))

        sli := make([]byte, 4096)
        n, err = conn.Read(sli)
        if err != nil {
            fmt.Println("conn.Read err:", err)
            return
        }
        if n == 0 {
            fmt.Println("检测到服务器关闭")
            return
        }
        fmt.Println("读到服务器回发的数据：", string(sli[:n]))
    }
}