go语言学习日记(8)

go语言的网络编程

TCP的cs结构

当涉及到 TCP（传输控制协议）的客户端-服务器（CS）架构时，它通常包括两个主要角色：客户端和服务器。这种架构允许客户端与服务器进行通信，服务器监听并响应来自客户端的请求。

服务器端：

监听：服务器通常在特定端口上监听传入的连接请求。
接受连接：当客户端尝试连接到服务器的指定端口时，服务器接受该连接请求并建立连接。
处理请求：一旦连接建立，服务器会处理客户端发送的请求。这可能涉及处理数据、执行特定任务或提供服务。
响应：服务器处理请求后，会向客户端发送响应。响应可能是数据、状态信息或执行结果。

客户端：

建立连接：客户端请求与服务器的特定端口建立连接。
发送请求：客户端向服务器发送请求，请求可能包含所需的数据、服务或特定操作。
等待响应：客户端等待服务器的响应。
处理响应：一旦收到服务器的响应，客户端会对其进行处理，可能是解析数据、采取相应操作或显示结果。

//服务器端代码
func dealconnect(conn net.Conn) {
    defer conn.Close()

    ipaddr := conn.RemoteAddr()
    fmt.Println("连接地址为:", ipaddr)

    buf := make([]byte, 1024) //建立缓冲池，等待客户端输入

    for {
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("writer err = ", err)
            return
        }

        result := string(buf[:n])

        fmt.Println(ipaddr, "发送数据为：", result)
        if result == "exit" {
            fmt.Println(ipaddr, "连接断开")
            return
        }
        conn.Write([]byte(strings.ToUpper(string(result)))) //将客户端发来的数据大写后送回客户端
    }
}

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:8000") //建立监听

    if err != nil {
        fmt.Println("listener err = ", err)
        return
    }

    defer listener.Close() //延迟关闭

    for {
        conn, err := listener.Accept() //处理客户端发来的链接
        if err != nil {
            fmt.Println("connect err = ", err)
            continue
        }

        go dealconnect(conn) //并发处理客户端发来的请求
    }
}

//客户端代码
package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:8000") //往服务器端发送请求链接
    if err != nil {
        fmt.Println("connect err = ", err)
        return

    }
    defer conn.Close()

    buf := make([]byte, 1024)
    for {
        fmt.Println("请传输内容:")
        fmt.Scan(&buf)
        fmt.Println("输入内容为:", buf)
        conn.Write(buf)

        n, err1 := conn.Read(buf)
        if err1 != nil {
            fmt.Println("Client Read err = ", err1)
            return
        }
        result := buf[:n]
        fmt.Printf("接收到数据[%d]:%s\n", n, string(result))
    }

}

简易的网络聊天室

网络主要流程

package main

import (
    "fmt"
    "net"
    "time"
)

type Client struct {
    C    chan string // 用于发送数据的管道
    Name string      // 用户名
    Addr string      // 网络地址
}

// 保存在线用户  cliAttr=>Client
var onlineMap map[string]Client;

var message = make(chan string);

// 只要有消息来了，遍历map，给map每个成员都发送此消息
func Manager() {
    // 给map分配空间
    onlineMap = make(map[string]Client);
    for {
        msg := <-message; // 没有消息时，这里会阻塞

        // 遍历map，给map每个成员都发送此消息
        for _, cli := range onlineMap {
            cli.C <- msg
        }
    }
}

// 向客户端发送消息
func WriteMsgToClient(cli Client, conn net.Conn) {
    for msg := range cli.C { // 给当前客户端发送信息
        _, _ = conn.Write([]byte(msg));
    }
}

// 获取要发送的消息
func MakeMsg(cli Client, text string) (buf string) {
    return "【" + cli.Addr + "】" + cli.Name + "：" + text + "\n";
}

func HandleConn(conn net.Conn) { // 处理用户连接（用户上线了的处理）
    // 获取客户端的网络地址
    cliAddr := conn.RemoteAddr().String();

    // 创建一个结构体
    cli := Client{make(chan string), cliAddr, cliAddr};

    // 把结构体添加到map
    onlineMap[cliAddr] = cli;

    // 新开一个协程，专门给客户端发送信息
    go WriteMsgToClient(cli, conn);

    // 广播某个人在线，所有客户端都能收到消息
    message <- MakeMsg(cli, "已登录");

    // 提示我是谁，这个只能自己收到
    cli.C <- MakeMsg(cli, "我在这里");

    //
    isQuit := make(chan bool);  // 对方是否主动退出
    hasData := make(chan bool); // 对方是否有数据发送

    // 接收用户发送过来的数据
    go func() {
        buf := make([]byte, 2048);
        for {
            n, readErr := conn.Read(buf);
            //if (readErr != nil) {
            //  fmt.Println("conn.Read error =", readErr);
            //}

            if (n == 0) { // 对方断开or出问题
                isQuit <- true;
                fmt.Println("conn.Read error =", readErr);
                return;
            }

            msg := string(buf[:n-1]); // nc 多一个换行

            if (len(msg) == 3 && msg == "who") { // 当收到“who”指令时，改为发送用户列表
                // 遍历map，给当前用户发送所有成员
                _, _ = conn.Write([]byte("User List:\n"));
                for _, tmp := range onlineMap {
                    msg = tmp.Addr + ":" + tmp.Name + "\n";
                    _, _ = conn.Write([]byte(msg));
                }
            } else if (len(msg) >= 8 && msg[:7] == "rename ") {
                // 更改用户名
                oldName := cli.Name;
                newName := msg[7:];
                cli.Name = newName;
                onlineMap[cliAddr] = cli;
                conn.Write([]byte("Client【" + cliAddr + "】的用户名更改" + oldName + "=>" + newName));
            } else {
                // 转发此内容
                fmt.Printf(MakeMsg(cli, msg));
                message <- MakeMsg(cli, msg);
            }

            hasData <- true; // 代表有数据
        }
    }()

    // 做个死循环，不要让方法结束
    for {
        // 通过select来检测channel的流动
        select {
        case <-isQuit:
            delete(onlineMap, cliAddr);     // 将当前用户从map中移除
            message <- MakeMsg(cli, "已退出"); // 广播下线
            return;
            //
        case <-hasData:
            break;
        case <-time.After(time.Second * 60):     // 60s后
            delete(onlineMap, cliAddr);          // 将当前用户从map中移除
            message <- MakeMsg(cli, "time out"); // 广播下线
            break;
        }

    }
}

func main() {
    listener, listenErr := net.Listen("tcp", ":8010");
    if (listenErr != nil) {
        fmt.Println("net.Listen error =", listenErr);
        return;
    }

    defer listener.Close();

    // 该协程用于转发消息，只要有消息来了，遍历map，给map每个成员都发送此消息
    go Manager();

    // 主协程，循环阻塞等待用户连接
    for {
        conn, connErr := listener.Accept();
        if (connErr != nil) {
            fmt.Println("listener.Accept =", connErr);
            continue;
        }

        go HandleConn(conn); // 处理用户连接
    }

}

小tips

WriteMsgToClient 函数中的conn变量是客户端连接的表示。当新消息到达时，服务器会通过这个连接将消息发送回客户端。这里的 cli 是一个客户端的数据结构，它包含有关客户端的其他信息，并充当一个接收消息并将消息发送到客户端连接的中介。
想象一下你在一个餐厅里。服务员（cli）正等待你的点餐，这个服务员知道你的桌号（网络地址）。每当你准备好下单时，服务员会将你的点餐信息（msg）传达给餐厅后厨（conn）。在这种情况下，服务员就像一个中介，他负责获取你的点餐信息并将其传送到厨房（网络连接）中。

go语言学习日记(8)

go语言的网络编程

简易的网络聊天室

推荐阅读更多精彩内容