GoLang Socket 聊天实例

 收发消息实体

package model

// 发送或者接收的消息信息
type SmsMessage struct {
    // 消息 类型  1 注册   2登陆  3在线状态  4私聊信息   5群发信息 6下线线状态   7 服务端返回信息  8 服务端返回客户端发送失败或错误信息
    Type int32 `json:"type"`
    // 消息体
    Data string `json:"data"`
}

// 登陆请求信息
type SmsLogin struct {
    UserId int32 `json:"userid"`
    Pwd string   `json:"pwd"`
    UserName string `json:username`
}

// 发送注册信息
type SmsRegister struct {
    UserInfo
}

// 发送在线状态信息
type SmsLineStatus struct {
    // 当前用户Id
    UserId int32 `json:"userid"`
    // 在线状态   1， 在线，2为 离线
    Status int32 `json:"status"`
}

// 私聊信息
type SmsToOne struct {
    // 信息发送者Id
    SendUserId int32 `json:"senduserid"`
    // 接收者Id
    ToUserId int32 `json:"touserid"`
    // 发送内容
    Context string `json:"context"`
}

// 群发信息
type SmsToAll struct {
    // 消息发送者Id
    SendUserId int32 `json:"senduserid"`
    Context string `json:"context"`
}

// 服务端返回客户端信息
type SmsResponse struct {
    Code int32 `json:"code"`
    OnLineUser []int32  `json:"onlineuser"`
    Error string `json:"error"`
}

// 服务端返回客户端发送失败或错误信息
type SmsErrorResponse struct {
    Code int32 `json:"code"`
    Error string `json:"error"`
}

用户信息实体

package model

import "net"

// 用户信息
type UserInfo struct {
    UserId int32 `json:"userid"`
    UserName string `json:"username"`
    Pwd string `json:"pwd"`
}

type UserLineMsg struct {
    UserId int32 `json:"userid"`
    Conn net.Conn `json:"conn"`
}

客户端收发消息 服务Struct

package services

import (
    "MySocket/Commit/model"
    "encoding/binary"
    "encoding/json"
    "fmt"
    "net"
)
// 客户端读写实体
type SmsReadWriteClientService struct{
    Conn net.Conn
}

// 客户端读取服务端发来的数据
func (this *SmsReadWriteClientService) ReadPkg() (sms model.SmsMessage,err error){
    fmt.Println("客户端读取服务器端发来的数据……")
    var Buf [8096]byte
    _,err =this.Conn.Read(Buf[:4])
    if err!=nil{
         fmt.Println("客户端读取服务器端发来的数据长度出错：",err)
         return
    }
    var pkgLen uint32
    pkgLen=binary.BigEndian.Uint32(Buf[0:4])
    n,err:=this.Conn.Read(Buf[:pkgLen])
    if n!=int(pkgLen){
        fmt.Println("客户端读取服务器端发来的数据长度与接收的长度不致！")
        return
    }
    if err!=nil{
        fmt.Println("客户端读取服务器端发来的数据出错：",err)
        return
    }
    err =json.Unmarshal(Buf[:pkgLen],&sms)
    if err!=nil{
        fmt.Println("客户端读取服务器端发来的数据返序列化出错：",err)
        return
    }
    return
}

// 客户端发关消息到服务器
func (this *SmsReadWriteClientService) WritePkg(data []byte) (err error){
    var Buf [8096]byte
   var pkgLen uint32
   pkgLen=uint32(len(data))
   binary.BigEndian.PutUint32(Buf[0:4],pkgLen)
   // 发送长度
   n,err :=this.Conn.Write(Buf[:4])
   if n!=4 {
       fmt.Println("客户端发送信息长度写实际长度不一致！")
          return
   }
   if err!=nil{
       fmt.Println("客户端发送信息长度信息错误：",err)
       return
   }

   // 发送消息本身
   n,err =this.Conn.Write(data)
   if n!=int(pkgLen) {
       fmt.Println("客户端发送消息体写实际长度不一致！")
   }
   if err!=nil{
       fmt.Println("客户端发送消息体写错误:",err)
   }
   return
}

客户端思路：

    定义全局变量    

package services
import (
    "MySocket/Client/model"
)
type  ConstInfo struct {

}
var (
    // 当前用户含net.Conn的信息
    CurUer model.CurUser
)

 

// 当前用户含net.Conn的信息
var CurUer model.CurUser

// 全局变量 在线的好友用户Id
var oneLineUser []int32

   *用户端连接服务器 先进行登陆，登陆成功后：

                                          1.实体化【当前用户含net.Conn的信息】

                                           2.显示当前所有好友 （这个信息在登陆成功时返回）

                                           3.使 用协程保持与服务器连接 去循环读取服务端发来消息，根据不同的消息类型做不同的处理：如：好友上线，私聊、群聊

                                           4.循环读取前端待发的消息体，在循环体内通用Conn向服务器发送消息 

代码如下：

   a.  客户端Main方法 建入用户名密码，构建消息实体

package main

import (
    "MySocket/Client/services"
    "MySocket/Commit/model"
    "encoding/json"
    "fmt"
)


func main()  {
    for {
        var user model.UserInfo
        var UserId, UserName, Pwd = 0, "", ""
        fmt.Println("请输入UserId……")
        fmt.Scanln(&UserId)
        user.UserId = int32(UserId)
        fmt.Println("请输入UserName……")
        fmt.Scanln(&UserName)
        user.UserName = UserName
        fmt.Println("请输入Pwd……")
        fmt.Scanln(&Pwd)
        user.Pwd = Pwd
        // 向服务器发送消息的结构体
        var sms model.SmsMessage
        byteUser, err := json.Marshal(user)
        if err != nil {
            fmt.Println("客户端输入用户信息转Json出错：", err)
            return
        }
        sms.Data = string(byteUser)
        // 消息类型=2 表示登陆
        sms.Type = 2
        sendInfo := services.UserSmsProcessService{}
        // 调用这个方法进行登陆
        err = sendInfo.SendLogin(sms,user)
        if err != nil {
            fmt.Println("登陆失败：", err)
        }
    }



}

b.      sendInfo.SendLogin(sms,user)  向服务器发送登陆信息，当登陆成功后，

                                           1.实体化【当前用户含net.Conn的信息】

                                           2.显示当前所有好友 （这个信息在登陆成功时返回）

                                           3.使 用协程保持与服务器连接 去循环读取服务端发来消息，根据不同的消息类型做不同的处理：如：好友上线，私聊、群聊

                                           4.循环读取前端待发的消息体，在循环体内通用Conn向服务器发送消息 

 

package services

import (
    "MySocket/Commit/model"
    "encoding/json"
    "fmt"
    "io"
    "net"
    "strings"
)
var (
    // 全局变量 在线好友的用户Id
    oneLineUser []int32
)

type UserSmsProcessService struct {
    // Conn net.Conn
}

// 用户 登陆操作
func (this UserSmsProcessService) SendLogin(sms model.SmsMessage,user model.UserInfo) (err error){
    // 建立连接
    Conn,err :=net.Dial("tcp","127.0.0.1:8090")
    if err!=nil{
        fmt.Println("客户端连接服务器出错……")
        return
    }
    defer Conn.Close()
    byteSms,err :=json.Marshal(sms)
    if err!=nil{
        fmt.Println("客户端登陆数据序列化出错:",err)
        return
    }
    sendInfo := &SmsReadWriteClientService{Conn: Conn}
    err= sendInfo.WritePkg(byteSms)
    if err!=nil{
        fmt.Println("客户端登陆发送到服务器出错:",err)
        return
    }
    // 获取登陆返回信息
    ReadInfo := &SmsReadWriteClientService{Conn: Conn}
    loginResultMsg,err := ReadInfo.ReadPkg()
    if err!=nil{
        fmt.Println("客户端送接收登陆返回结果错误:",err)
        return
    }
     var response model.SmsResponse
    err = json.Unmarshal([]byte(loginResultMsg.Data),&response)
    if err!=nil{
        fmt.Println("客户端送接收登陆返回结果返序列化错误:",err)
        return
    }
    if response.Code==200{
        fmt.Println("登陆200……")
        //  1.实体化【当前用户含net.Conn的信息】
        CurUer.UserId=user.UserId
        CurUer.UserName=user.UserName
        CurUer.Conn=Conn
        oneLineUser= make([]int32,0)
        // 将当前在线的用户添加到客户端 全局 在线用户上去
        oneLineUser = append(oneLineUser, response.OnLineUser...)
        // 2.显示当前在线信息
        showinfo :=&ShowInfo{}
        showinfo.ShowOnLineUer(oneLineUser)
        /// *************** 3.保留该方法与服务端保持连接 *******************
        // 3.根据客户端接收到不同的消息做相应的处理    这里特别重要 *******************************
        go this.ServiceAndClientLine(Conn)
        for{    // 4.然后根据需要 随时向服务器发送想发的消息  注意：这里特别重要……**************************
            // 构造待发的消息体  通过输入的方式
            smsWaitSend,err:= showinfo.ShowMenuAndEnterSendContext()
            if err!=nil{
                fmt.Println("构建群聊或私聊包时出错:",err)
                continue
            }
            // 发送想要发的消息
            err= sendInfo.WritePkg(smsWaitSend)
            if err!=nil{
                fmt.Println("发送群聊或私聊出错:",err)
            }
        }
    }else {
        fmt.Println("登陆500……")
        fmt.Println("登陆失败")
        return
    }
    return
}



/// *************** 保留该方法与服务端保持连接 *******************
func (this *UserSmsProcessService) ServiceAndClientLine(Conn net.Conn){
    readOrWrite :=&SmsReadWriteClientService{Conn: Conn}
    for {
        fmt.Println("客户端正在等待服务端发送消息")
        sms,err := readOrWrite.ReadPkg()
        if err!=nil{
            if strings.Contains(err.Error(),"wsarecv: An existing connection was forcibly closed by the remote host."){
                Conn.Close()
                fmt.Println("与服务器断开了链接……")
                return
            }
            if err==io.EOF{
                fmt.Println("与服务器断开了链接……")
                return
            }
            fmt.Println("客户端正在等待服务端发送消息")
            continue
        }
        switch sms.Type {
            case 3:  // 有新用户上线
                var modelStatus model.SmsLineStatus
                err:= json.Unmarshal([]byte(sms.Data),&modelStatus)
                if err!=nil{
                    fmt.Println("接收服务器用户上线状态反序列化失败:",err)
                    continue
                }
                // 将新上线的用户添加到  在线用户列表中
                oneLineUser = append(oneLineUser, modelStatus.UserId)
                // 重新显示在线用户列表
                showinfo :=&ShowInfo{}
                showinfo.ShowOnLineUer(oneLineUser)
            case 4:     // 接到到的是私聊信息
                var toOne model.SmsToOne
                err:= json.Unmarshal([]byte(sms.Data),&toOne)
                if err!=nil{
                    fmt.Println("接收服务器用户私聊信息反序列化失败:",err)
                    continue
                }
                fmt.Println("用户：",toOne.SendUserId,"对你发来私信：",toOne.Context)
            case 8:
                fmt.Println(sms.Data)
            default:
        }
        // 用户自己也可以进行发送信息操作
        //showInfo :=&ShowInfo{}
        //showInfo.ShowMenuAndEnterSendContext()

    }
}

 

            上面的客户终端输入构建消息实体的方法及显示在线用户 见下：

package services

import (
    "MySocket/Commit/model"
    "encoding/json"
    "fmt"
)


type ShowInfo struct {

}

// 显示当前在线的用户
func (this *ShowInfo) ShowOnLineUer(users []int32){
    fmt.Println("当前在线用户Start：")
    for _,v :=range users{
        fmt.Println(v)
    }
    fmt.Println("当前在线用户End!")
}

/// 显示聊天菜单，根据自身需要建立发送聊天消息，准备发送
func (this *ShowInfo) ShowMenuAndEnterSendContext() (byteSms []byte,err error){
    var codeEnter int32
    var userId int32
    var Context string
    var sms model.SmsMessage
    fmt.Println("-------4. 私聊消息---------")
    fmt.Println("-------5. 群聊消息---------")
    fmt.Scanln(&codeEnter)
    sms.Type=codeEnter
    if codeEnter==4{
         var toone model.SmsToOne
         toone.SendUserId=CurUer.UserId
        fmt.Println("-------输入私聊人的UserId---------")
        fmt.Scanln(&userId)
         toone.ToUserId=userId
        fmt.Println("-------输入私聊人内容---------")
        fmt.Scanln(&Context)
         toone.Context=Context
         byteToone,err:=json.Marshal(toone)
         if err!=nil{
             fmt.Println("私聊内容序列化出错！",err)
             return this.ShowMenuAndEnterSendContext()
         }
         sms.Data=string(byteToone)

    }else  if codeEnter==5{
         var toall model.SmsToAll
         toall.SendUserId=CurUer.UserId
         fmt.Println("-------输入群聊内容---------")
         fmt.Scanln(&Context)
         byteToall,err :=json.Marshal(toall)
        if err!=nil{
            fmt.Println("私聊内容序列化出错！",err)
            return this.ShowMenuAndEnterSendContext()
        }
        sms.Data=string(byteToall)

    }else {
        fmt.Println("-------4. 私聊消息或5. 群聊消息---------")
        return this.ShowMenuAndEnterSendContext()
    }
    byteSms,err= json.Marshal(sms)
    if err!=nil{
        fmt.Println("构建聊天消息体序列化时出错：",err)
        return this.ShowMenuAndEnterSendContext()
    }
    return

}

 

服务端思路：

                      1.先监听端口，循环接收客户端连接，每个连接用一个协程来进行处理，

                      2.循环读取各连接发来的信息

                      3.根据发来不同类型的数据进行不同处理 ，如 登陆 -- 不管成功与否---返回客户端信息（成功还要返回在线的好友信息）

                                                                                                私聊信息-----定位私聊用户-------向其发送私聊信息

                                                                                                 群聊信息-----遍历当前所有在线用户-------分别发送群聊信息（注意发送给各用户的net.Conn使用*********特别注意）

服务器收发信息方法代码

package services

import (
    "MySocket/Commit/model"
    "encoding/binary"
    "encoding/json"
    "fmt"
    "net"
)

// 发送和读取信息
type  SmsReadWriteService struct {
    Conn net.Conn
}

// 读取客户端发来的信息
func (this *SmsReadWriteService) ReadPkg() (msg model.SmsMessage,err error){
    var Buf [8096]byte //这时传输时，使用缓冲
    fmt.Println("读取客户端发送的信息……")
    _,err =this.Conn.Read(Buf[:4])
    if err!=nil{
        fmt.Println("读取客户端送的字节数出错:",err,"……")
        return
    }
    var pkgLen uint32
    // 将读取到的字节数组转化成Uint32的数据长度
    pkgLen=binary.BigEndian.Uint32(Buf[0:4])
    // 读取该长度的数据
    n,err :=this.Conn.Read(Buf[:pkgLen])
    if n!=int(pkgLen){
        fmt.Println("服务端读取的字节数与接收到的字节数不一致^")
        return
    }
    if err!=nil{
        fmt.Println("服务端读取数据错误 ：",err,"……")
        return
    }
    err = json.Unmarshal(Buf[:pkgLen],&msg)
    if err!=nil{
        fmt.Println("服务端读取的Buf[:pkgLen]返序列化成SmsMessage出错：",err,"……")
    }
    return
}

func (this *SmsReadWriteService) WritePkg(data []byte) (err error){
    // 先发送一个长度给对方
    var Buf [8096]byte //这时传输时，使用缓冲
    var pkgLen uint32
    pkgLen =uint32(len(data))
    binary.BigEndian.PutUint32(Buf[0:4],pkgLen)
    // 发送长度
    n,err :=this.Conn.Write(Buf[:4])
    if n!=4{
        fmt.Println("服务端写入数据与发送长度不一致^")
        return
    }
    if err!=nil{
        fmt.Println("服务端写入的Buf[:pkgLen]出错：",err,"……")
        return
    }
    // 发送消息本身
    n,err=this.Conn.Write(data)
    if n!=int(pkgLen) {
        fmt.Println("服务端写入数据与发送的【消息体】长度不一致^")
        return
    }
    if err!=nil{
        fmt.Println("服务端写入消息体出错：",err,"……")
        return
    }
    return

}

 

 

全局变量      

// 当前在线用户Map集合 在init()方法里实例化
OnLineUserMap map[int32]model.UserLineMsg

Main方法入口
 1.先监听端口，循环接收客户端连接

package main

import (
    "MySocket/Service/services"
    "fmt"
    "net"
)

func ResponseClientRequest(conn net.Conn){
    defer conn.Close()
    processService :=&services.ProcessorService{}
    // 循环接收客户端发来的信息，然后根据消息类型来做相应的处理
    processService.ProcessorRead(conn)
}

func main()  {
    fmt.Println("服务器开始监听127.0.0.1:8090！")
    listen,err :=net.Listen("tcp","127.0.0.1:8090")
    if err!=nil {
        fmt.Println("服务器监听127.0.0.1:8090失败！")
        return
    }
    defer listen.Close()
    for{
        conn,errCon:= listen.Accept()
        if errCon!=nil{
            fmt.Println("有一个连接失败……")
            continue
        }
        fmt.Println("客户端连接成功……")
        go ResponseClientRequest(conn)
    }

}

每个连接用一个协程来进行处理，循环读取各连接发来的信息

package services

import (
    "MySocket/Commit/model"
    "fmt"
    "io"
    "net"
)
var (
    // 当前在线用户Map集合
    OnLineUserMap map[int32]model.UserLineMsg
)
func init(){
    // 初始化当前  当前在线用户Map集合
    OnLineUserMap=make(map[int32]model.UserLineMsg)
}

type ProcessorService struct {
    // Conn net.Conn
}

// 循环读取客户端发送过来的信息
func (this *ProcessorService)  ProcessorRead(Conn net.Conn) (err error){
    // 循环读取客户端发送过来的信息
    for{
        read :=&SmsReadWriteService{
            Conn: Conn,
        }
        msg,err :=read.ReadPkg()
        if err!=nil{
            if err==io.EOF{
                fmt.Println("客户端退出，服务器端也退出..")
                return err
            }else {
                fmt.Println("readPkg err=", err)
                return err
            }
        }
        // 根据服务端接收的消息类型来做相应处理
        err =this.ProcessorReadMsg(&msg,Conn)
        if err!=nil{
            return err
        }
    }

}

// 根据服务端接收的消息类型来做相应处理
func (this *ProcessorService) ProcessorReadMsg(msg *model.SmsMessage,Conn net.Conn) (err error){

    //看看是否能接收到客户端发送的群发的消息
    fmt.Println("mes=", msg)
    // 消息 类型  1 注册   2登陆  3在线状态  4私聊信息   5群发信息
    switch msg.Type {
    case 1: // 处理注册信息
    case 2:
        one := &UserMsgProcessService{ // 用户信息处理
            Conn: Conn,
        }
        // 传递上线信息
        one.LoginInfo(msg)
    case 3: // 3在线状态 息
    case 4:         //4私聊信息
        toone := &UserMsgProcessService{ // 用户信息处理
             Conn: Conn,
        }
        toone.SendToOneMsg(msg)
    case 5: // 5群发信息

    }


    return
}

3.根据发来不同类型的数据进行不同处理 

package services

import (
    "MySocket/Commit/model"
    "encoding/json"
    "fmt"
    "net"
)

// 用户消息处理服务
type  UserMsgProcessService struct {
    Conn net.Conn
}


//// 处理登陆信息       Start
// 处理客户端发送过来的登陆信息
func (this *UserMsgProcessService) LoginInfo(msg *model.SmsMessage)  (err error){
    var login model.SmsLogin
    err =json.Unmarshal([]byte(msg.Data),&login)
    if err !=nil{
        fmt.Println("服务器处理登陆时出错：",err)
        return err
    }
    var smsResponse model.SmsResponse
    if login.Pwd=="123"{
        smsResponse.Code=200
        var model model.UserLineMsg
        model.UserId=login.UserId
        model.Conn=this.Conn
        OnLineUserMap[login.UserId]=model   // 将某人上线的信息写入到在线Map中
        userArr :=this.SendOneOnLine(login.UserId)   // 通知相关好友 当前用户上线了，并返回当前在线的人的IduserArr
        smsResponse.OnLineUser=userArr
    } else {
        smsResponse.Code=500
        smsResponse.Error="密码错误，请重新输入……"
    }
    byteSms,err :=json.Marshal(smsResponse)
    if err!=nil{
        fmt.Println("服务器处理返回信息时smsResponse转JSon出错：",err)
        return err
    }
    var response model.SmsMessage
    response.Type=7
    response.Data=string(byteSms)
    // 向客户端发送登陆是否成功的 状态码和错误 信息
    err = this.SendLoginOverToClient(response)
    return err
}


// 服务器告知相关好友，某人上线了  并返回当前在线的人的Id集userArr
func (this *UserMsgProcessService) SendOneOnLine(UserId int32) (userArr []int32){
    userArr=make([]int32,0)
    for _,v :=range OnLineUserMap{
        userArr = append(userArr,v.UserId )
        if v.UserId==UserId{
            continue
        }
        // 发送格式下的  上下线 实体
        var lineStatus model.SmsLineStatus
        lineStatus.UserId=UserId   // 谁上线了
        lineStatus.Status=3   // 上线
        // 向v用户发送UserId 上线状态 *****************************
        this.SendOneOnLineMsg(v,lineStatus)
    }
    return userArr
}

// 向某单个好友 发送上线用户的上线壮态或下线壮态  status=3 上线  status=6下线
// lineStatus model.SmsLineStatus   发送的上下线实体
// lineStatus.UserId=UserId   // 谁上线了
// lineStatus.Status=3    // 上线3 下线 6
func (this *UserMsgProcessService) SendOneOnLineMsg(u model.UserLineMsg,lineStatus model.SmsLineStatus){

    byteStatus,err :=json.Marshal(lineStatus)
    if err!=nil{
        fmt.Println("服务器处理byteStatus发送用户上线状态时出错：",err)
        return
    }
    // 发送消息实体
    var model model.SmsMessage
    // 消息类型 为上下线状态
    model.Type=lineStatus.Status
    model.Data=string(byteStatus)
    byteData,err :=json.Marshal(model)
    if err !=nil{
        fmt.Println("服务器处理byteData发送用户上线状态时出错：",err)
        return
    }
    //创建消息读写服务实例
    sendInfo :=&SmsReadWriteService{
        Conn: u.Conn,   // 注意  这里的Conn 是要发给谁的Conn *****************
    }
    // 向当前u用户发送某用户上下线消息
    sendInfo.WritePkg(byteData)
}

// 向客户端发送登陆是否成功的 状态码和错误 信息
func (this *UserMsgProcessService) SendLoginOverToClient(model model.SmsMessage) (err error){
    byteModel,err :=json.Marshal(model)
    if err!=nil{
        fmt.Println("服务器处理登陆结果转Json时出错：",err)
        return  err
    }
    sendInfo :=&SmsReadWriteService{
        Conn: this.Conn,
    }
    err= sendInfo.WritePkg(byteModel)
    return err

}

//// 处理登陆信息       End


// 有客户端发送私聊信息  处理
func (this UserMsgProcessService) SendToOneMsg(sms *model.SmsMessage) (err error){
    byteSms,err :=json.Marshal(sms)
    if err!=nil{
        fmt.Println("服务器序列化私聊整体消息时出错：",err)
        return
    }
    var smsToOne model.SmsToOne
    err= json.Unmarshal([]byte(sms.Data),&smsToOne)
    if err!=nil{
        fmt.Println("服务器返序列化私聊消息对像时出错：",err)
        return
    }
    // 定义接收人是否存在
    var userExists bool=false
    for _,v :=range OnLineUserMap{
        if v.UserId==smsToOne.ToUserId{
            userExists=true
            sendInfo :=&SmsReadWriteService{
                Conn: v.Conn,    // 注意这里Conn的传递，不要传错*****************
            }
            // 向私聊人发送私聊消息
            err=sendInfo.WritePkg(byteSms)
            if err!=nil{
                fmt.Println("服务器发送私聊消息时出错：",err)
            }
            return
        }
    }
    // 假如接收人不存在
    if !userExists{
        var errSms model.SmsErrorResponse
        errSms.Code=500
        errSms.Error="找不到该用户"
        sms.Type=8
        byteErrContext,err:= json.Marshal(errSms)
        if err!=nil{
            fmt.Println("服务器发找不到私聊用户返回内部信息序列化出错：",err)
            return err
        }
        sms.Data=string(byteErrContext)
        byteErrSms,err :=json.Marshal(sms)
        if err!=nil{
            fmt.Println("服务器发找不到私聊用户返回整体信息序列化出错：",err)
            return err
        }
        sendInfo :=&SmsReadWriteService{
            Conn: this.Conn,
        }
        err= sendInfo.WritePkg(byteErrSms)
    }
    return
}