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
}

GoLang Socket 聊天实例

收发消息实体

用户信息实体

客户端收发消息 服务Struct

客户端思路：

定义全局变量

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

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

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

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

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

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

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

代码如下：

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

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

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

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

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

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

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

服务端思路：

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

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

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

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

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

服务器收发信息方法代码

全局变量

// 当前在线用户Map集合 在init()方法里实例化OnLineUserMap map[int32]model.UserLineMsgMain方法入口 1.先监听端口，循环接收客户端连接

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

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

客户端收发消息服务Struct

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

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

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

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

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

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

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

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

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

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

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

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