浅学计网：Socket

package main

import (
	"fmt"
	"log"
	"net"
	"strings"
)

func dealConn(conn net.Conn) {

	defer conn.Close() //此函数结束时，关闭Socket

	//conn.RemoteAddr().String()：连接客服端的网络地址
	ipAddr := conn.RemoteAddr().String()
	fmt.Println(ipAddr, "连接成功")

	buf := make([]byte, 1024) //缓冲区，用于接收客户端发送的数据

    // 阻塞等待用户发送的数据
	for {
		n, err := conn.Read(buf) //n接收数据的长度
		if err != nil {
			fmt.Println(err)
			return
		}
		//切片截取，只截取有效数据
		result := buf[:n]
		fmt.Printf("接收到数据来自[%s]==>[%d]:%s\n", ipAddr, n, string(result))
		if "exit" == string(result) { //如果对方发送"exit"，退出此链接
			fmt.Println(ipAddr, "退出连接")
			return
		}

		//把接收到的数据转换为大写，再给客户端发送
		conn.Write([]byte(strings.ToUpper(string(result))))
	}
}

func main() {
	//创建、监听socket
	listenner, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		log.Fatal(err) //log.Fatal()会产生panic
	}

	defer listenner.Close()

	for {
		conn, err := listenner.Accept() //阻塞等待客户端连接
		if err != nil {
			log.Println(err)
			continue
		}

		go dealConn(conn)
	}
}

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	//客户端主动连接服务器
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		log.Fatal(err) //log.Fatal()会产生panic
		return
	}

	defer conn.Close() //关闭

	buf := make([]byte, 1024) //缓冲区
	for {
		fmt.Printf("请输入发送的内容：")
		fmt.Scan(&buf)
		fmt.Printf("发送的内容：%s\n", string(buf))

		//发送数据
		conn.Write(buf)

		//阻塞等待服务器回复的数据
		n, err := conn.Read(buf) //n代码接收数据的长度
		if err != nil {
			fmt.Println(err)
			return
		}

		//切片截取，只截取有效数据
		result := buf[:n]
		fmt.Printf("接收到据[%d]:%s\n", n, string(result))
	}
}

 package chat_api
 ​
 import (
     "encoding/json"
     "fmt"
     "gin-vue-blog/global"
     "gin-vue-blog/models"
     "gin-vue-blog/models/ctype"
     "gin-vue-blog/utils"
     "gin-vue-blog/utils/resp"
     "github.com/DanPlayer/randomname"
     "github.com/gin-gonic/gin"
     "github.com/gorilla/websocket"
     "net/http"
     "path"
     "strings"
     "time"
 )
 ​
 // ChatGroupRequest 入参
 type ChatGroupRequest struct {
     MsgContent string        `json:"msg_content"`
     MsgType    ctype.MsgType `json:"msg_type"`
 }
 ​
 // ChatGroupResponse 出参
 type ChatGroupResponse struct {
     NickName   string        `json:"nick_name"`
     Avatar     string        `json:"avatar"`
     MsgContent string        `json:"msg_content"`
     MsgType    ctype.MsgType `json:"msg_type"`
     Date       string        `json:"date"`
 ​
     OnlineCount int `json:"online_count"`
 }
 ​
 type ChatUser struct {
     Conn     *websocket.Conn // 客户端连接
     NickName string          `json:"nick_name"`
     Avatar   string          `json:"avatar"`
 }
 ​
 var connGroup = make(map[string]ChatUser)
 ​
 // ChatGroupView 群聊
 func (ChatApi) ChatGroupView(c *gin.Context) {
     // 1. 定义一个 websocker.Upgrader 结构。
     // 这将保存诸如 WebSocket 连接的读取和写入缓冲区大小之类的信息
     upGrader := websocket.Upgrader{}
 ​
     // 2. 检查传入来源
     // 确定是否允许来自不同域的传入请求连接，如果不是，它们将被CORS错误击中。
     upGrader.CheckOrigin = func(r *http.Request) bool { return true }
 ​
     // 3. 升级的HTTP连接
     conn, err := upGrader.Upgrade(c.Writer, c.Request, nil)
     if err != nil {
         resp.FailWithMsg(c, "群聊功能启动失败")
         global.Log.Error(err)
         return
     }
 ​
     // 随机生成昵称，根据昵称第一个字关联头像地址
     nickName := randomname.GenerateName()
     avatarPath := path.Join("/uploads/chat_avatar", string([]rune(nickName)[0])+".png")
     addr := conn.RemoteAddr().String()
     chatUser := ChatUser{
         Conn:     conn,
         NickName: nickName,
         Avatar:   avatarPath,
     }
     connGroup[addr] = chatUser // 记录客户端
 ​
     // 4. 持续聆听该连接
     for {
         // 4.1 监听消息
         _, messageBytes, err := conn.ReadMessage()
         if err != nil { // 用户断开连接
             SendMsgToAllClint(addr, ChatGroupResponse{
                 NickName:    chatUser.NickName,
                 Avatar:      chatUser.Avatar,
                 MsgContent:  fmt.Sprintf("[%s]退出聊天室", chatUser.NickName),
                 MsgType:     ctype.OutRoomMsg,
                 Date:        time.Now().Format("2006-01-02 15:04:05"),
                 OnlineCount: len(connGroup) - 1,
             })
             break
         }
 ​
         // 4.2 消息参数绑定
         var chatGroupRequest ChatGroupRequest
         err = json.Unmarshal(messageBytes, &chatGroupRequest)
         if err != nil { // 参数绑定失败，给这个客户端反馈即可
             SendMsgToOneClint(addr, ChatGroupResponse{
                 NickName:    chatUser.NickName,
                 Avatar:      chatUser.Avatar,
                 MsgType:     ctype.SystemMsg,
                 MsgContent:  "消息参数绑定失败！",
                 OnlineCount: len(connGroup),
             })
             continue
         }
 ​
         // 4.3 判断类型，根据不同类型，做不同分发逻辑
         switch chatGroupRequest.MsgType {
             case ctype.TextMsg: // 普通文本类型
             if strings.TrimSpace(chatGroupRequest.MsgContent) == "" {
                 SendMsgToOneClint(addr, ChatGroupResponse{
                     NickName:    chatUser.NickName,
                     Avatar:      chatUser.Avatar,
                     MsgType:     ctype.SystemMsg,
                     MsgContent:  "消息内容不能为空",
                     OnlineCount: len(connGroup),
                 })
                 continue
             }
             SendMsgToAllClint(addr, ChatGroupResponse{
                 NickName:    chatUser.NickName,
                 Avatar:      chatUser.Avatar,
                 MsgContent:  chatGroupRequest.MsgContent,
                 MsgType:     ctype.TextMsg,
                 Date:        time.Now().Format("2006-01-02 15:04:05"),
                 OnlineCount: len(connGroup),
             })
 ​
             case ctype.InRoomMsg: // 进入聊天室通知；会有一个进入聊天室按钮，点击之后，前端发送InRoomMsg过来
             SendMsgToAllClint(addr, ChatGroupResponse{
                 NickName:    chatUser.NickName,
                 Avatar:      chatUser.Avatar,
                 MsgContent:  fmt.Sprintf("[%s] 进入聊天室", chatUser.NickName),
                 MsgType:     ctype.InRoomMsg,
                 Date:        time.Now().Format("2006-01-02 15:04:05"),
                 OnlineCount: len(connGroup),
             })
             default:
             SendMsgToOneClint(addr, ChatGroupResponse{ // 系统反馈
                 NickName:    chatUser.NickName,
                 Avatar:      chatUser.Avatar,
                 MsgType:     ctype.SystemMsg,
                 MsgContent:  "消息类型错误",
                 OnlineCount: len(connGroup),
             })
         }
     }
     defer func(conn *websocket.Conn) {
         err := conn.Close()
         if err != nil {
             global.Log.Errorf("websocket关闭失败. Error: %s", err)
             return
         }
     }(conn)
     delete(connGroup, addr)
 ​
 }
 ​
 // SendMsgToAllClint 发送信息到所有客户端
 // TODO: 这里暂且写为文本类型，后续可以完善图片、视频、语音的发送，对应的就是二进制类型
 func SendMsgToAllClint(senderAddr string, chatGroupResponse ChatGroupResponse) {
     ...
     byteData, _ := json.Marshal(chatGroupResponse)
     for _, chatUser := range connGroup {
         _ = chatUser.Conn.WriteMessage(websocket.TextMessage, byteData)
     }
 }
 ​
 // SendMsgToOneClint 系统消息，发送给指定客户端
 // TODO: 这里暂且写为文本类型，后续可以完善图片、视频、语音的发送，对应的就是二进制类型
 func SendMsgToOneClint(receiverAddr string, response ChatGroupResponse) {
     ...
     bytes, _ := json.Marshal(response)
     chatUser := connGroup[receiverAddr]
     _ = chatUser.Conn.WriteMessage(websocket.TextMessage, bytes)
 }
 ​
 // 获取用户 IP 和 地址
 func getIpAndUserAddr(addr string) (string, string) {}