前言：

上篇文章说道我们怎么通过不同的数据去调用框架中不同的函数，在socket编程中，服务器做的不仅仅是接受信息，还需要推送消息，最典型的场景就是聊天室了，每当一个客户端发送一个一条消息，服务端就需要把这条消息，循环发送给其它所有客户端。已经把所有代码整合了，希望给个星星支持一下 microSocket。

实现思路：

我们知道在go语言socket编程时，服务端向客户端发送信息只需要 调用 conn.write()即可，一个连接就对应一个conn，每次服务端从一个客户端消息的时候，想要推送给别的客户端信息就需要别的客户端的coon，所以我们的解决思路就是

1. 每次客户端和服务端握手成功后，就把当前的conn，保存到全局 协程安全的map里
2. 当客户端与服务端断开连接的时候就把这个coon从map里面删除

每次服务器要广播全体的时候，就把当前的 map遍历一遍，一次推送就好了

代码实现：

每次连接成功的时候就把coon 封装成一个session

for {
        //不断地结束新的客户端连接
        conn, err := tcpListen.Accept()
        if err != nil {
            log.Println(err)
            continue
        }
        //把conn封装成一个session
        sess := NewSession(fd, conn)
        //把session 保存到sessionMaster
        this.SessionMaster.SetSession(fd, sess)
        fd++
        go this.connHandle(conn, sess)
    }

session 和sessionMaster的实现

//-------------------------------------------一个session代表一个连接------------------------------------------
type session struct {
    id    uint32
    con   net.Conn
    times int64
    lock  sync.Mutex
}

func NewSession(id uint32, con net.Conn) *session {
    return &session{
        id:    id,
        con:   con,
        times: time.Now().Unix(),
    }
}
//向conn写数据
func (this *session) write(msg string) error {
    this.lock.Lock()
    defer this.lock.Unlock()
    _ ,errs := this.con.Write([]byte(msg))
    return errs
}
//关闭conn
func (this *session)close(){
    this.con.Close()
}

//.......................................SESSION管理类.......................................

type SessionM struct {
    sessions map[uint32]*session
    num      uint32
    lock     sync.RWMutex
}

func NewSessonM() *SessionM {
    return &SessionM{
        sessions: make(map[uint32]*session),
        num:      0,
    }
}

func (this *SessionM) GetSessionById(id uint32) *session {
    if v, exit := this.sessions[id]; exit {
        return v
    }
    return nil
}

func (this *SessionM) SetSession(id uint32, sess *session) {
    this.lock.Lock()
    defer this.lock.Unlock()
    this.sessions[id] = sess
}

//关闭连接并删除
func (this *SessionM) DelSessionById(id uint32) {
    this.lock.Lock()
    defer this.lock.Unlock()
    if v,exit := this.sessions[id];exit{
        v.con.Close()
    }
    delete(this.sessions, id)
}

func (this *SessionM) WriteByid(id uint32, msg string) bool {
    if v, exit := this.sessions[id]; exit {
        if err := v.write(msg); err != nil {
            this.DelSessionById(id)
            return false
        } else {
            return true
        }
    }
    return false
}

代码解释：

1. 首先我们要封装一个session类，一个session就对应一个conn，大家可能发现到了，为什么conn.write
   我们要加锁呢。原因也很简单，就是为了保证，同一时间，最多只会有一个协程向一个coon写数据，如果有多个协程同时写的话，就会发生数据混乱，所以这里的锁是很有必要的！
2. 接下来就是sessionMaster类，服务端就是通过它来对所有客户端的连接进行操作，它的核心，其实就是一个sessions 的map，该map在删除和插入新数据时都有加锁处理，确保协程安全。当服务端想要像客户端推送消息的时候直接调用write方法就好了如下：

ser.SessionMaster.WriteByid(uint32(fd), "Hello")

总结:

1. 通过全局sessionMaster对所有客户端的连接进行统一管理，方便推送客户端数据
2. 每次对客户端推送数据时必须要加锁，不然数据可能会错乱

至此我们的socket框架分享，已经差不多讲完了，有什么不懂得，或者意见欢迎留言评论。