适合新手：手把手教你用Go快速搭建高性能、可扩展的IM系统(有源码)

“  本文原文共2万5千字，篇幅太长，为了体升阅读体验已做删减和优化， 如需阅读全文，请前往即时通讯网(52im.net)社区： http://www.52im.net/thread-2988-1-1.html  或点击下方的 “ 阅读原文 ”！

0、引言

本文为开源工程：“github.com/GuoZhaoran/fastIM”的配套文章，原作者：“绘你一世倾城”，现为：猎豹移动 php 开发工程师，感谢原作者的技术分享。

• 主地址： https://github.com/GuoZhaoran/fastIM

• 备地址： https://github.com/52im/fastIM

52im.net的另几篇同类代码你可能也喜欢：

• 《 自已开发IM有那么难吗？手把手教你自撸一个Andriod版简易IM (有源码) 》

• 《 拿起键盘就是干：跟我一起徒手开发一套分布式IM系统 》

• 《 适合新手：从零开发一个IM服务端（基于Netty，有完整源码） 》

另外： 本文作者的另一篇文章，有兴趣也可以关注一下：《 12306抢票带来的启示：看我如何用 Go 实现百万QPS的秒杀系统(含源码) 》。

1、内容概述

• 1）本文演示的IM系统包含基本的注册、登录、添加好友基础功能；

• 2）提供单聊、群聊，并且支持发送文字、表情和图片，在搭建的系统上，读者可轻松的拓展语音、视频聊天、发红包等业务。

• 2）为了帮助读者更清楚的理解IM系统的原理，第3节我会专门深入讲解一下websocket协议，websocket是长链接中比较常用的协议；

• 3）然后第4节会讲解快速搭建IM系统的技巧和主要代码实现；

• 4）在第5节笔者会对IM系统的架构升级和优化提出一些建议和思路；

• 5）在最后章节做本文的回顾总结。

2、理解websocket协议

WebSocket的目标是在一个单独的持久连接上提供全双工、双向通信。在Javascript创建了Web Socket之后，会有一个HTTP请求发送到浏览器以发起连接。在取得服务器响应后，建立的连接会将HTTP升级从HTTP协议交换为WebSocket协议。

由于WebSocket使用自定义的协议，所以URL模式也略有不同。未加密的连接不再是http://，而是ws://;加密的连接也不是https://，而是wss://。在使用WebSocket URL时，必须带着这个模式，因为将来还有可能支持其他的模式。

使用自定义协议而非HTTP协议的好处是，能够在客户端和服务器之间发送非常少量的数据，而不必担心HTTP那样字节级的开销。由于传递的数据包很小，所以WebSocket非常适合移动应用。

本节内容太多，此处已删减约5000字 ，原文请见52im社区链接： http://www.52im.net/thread-2988-1-1.html ， 或点击下方的“ 阅读原文 ”！

3、开始动手

3.1 系统架构和代码文件目录结构

下图是一个比较完备的IM系统架构： 包含了C端（ 客户端 ）、接入层（ 通过协议接入 ）、S端（ 服务端 ）处理逻辑和分发消息、存储层用来持久化数据。

简要介绍一下本次IM的技术实现情况：

• 1）我们本节C端使用的是Webapp, 通过Go语言渲染Vue模版快速实现功能；

• 2）接入层使用的是websocket协议，前边已经进行了深入的介绍；

• 3）S端是我们实现的重点，其中鉴权、登录、关系管理、单聊和群聊的功能都已经实现，读者可以在这部分功能的基础上再拓展其他的功能，比如：视频语音聊天、发红包、朋友圈等业务模块；

• 4）存储层我们做的比较简单，只是使用 Mysql 简单持久化存储了用户关系，然后聊天中的图片资源我们存储到了本地文件中。

app
│   ├── args
│   │   ├── contact.go
│   │   └── pagearg.go
│   ├── controller           //控制器层，api入口
│   │   ├── chat.go
│   │   ├── contract.go
│   │   ├── upload.go
│   │   └── user.go
│   ├── main.go             //程序入口
│   ├── model               //数据定义与存储
│   │   ├── community.go
│   │   ├── contract.go
│   │   ├── init.go
│   │   └── user.go
│   ├── service             //逻辑实现
│   │   ├── contract.go
│   │   └── user.go
│   ├── util                //帮助函数    
│   │   ├── md5.go
│   │   ├── parse.go
│   │   ├── resp.go
│   │   └── string.go
│   └── view                //模版资源
│   │   ├── ...
asset                       //js、css文件
resource                    //上传资源，上传图片会放到这里

源码的具体说明如下：

• 1）从入口函数main.go开始，我们定义了controller层，是客户端api的入口；

• 2）service用来处理主要的用户逻辑，消息分发、用户管理都在这里实现；

• 3）model层定义了一些数据表，主要是用户注册和用户好友关系、群组等信息，存储到mysql；

• 4）util包下是一些帮助函数，比如加密、请求响应等；

• 5）view下边存储了模版资源信息，上边所说的这些都在app文件夹下存储；

• 6）外层还有asset用来存储css、js文件和聊天中会用到的表情图片等；

• 7）resource下存储用户聊天中的图片或者视频等文件。

3.2 10行代码万能模版渲染

func registerView() {
        tpl, err := template.ParseGlob("./app/view/**/*")
        if err != nil {
                log.Fatal(err.Error())
        }
        for _, v := range tpl.Templates() {
                tplName := v.Name()
                http.HandleFunc(tplName, func(writer http.ResponseWriter, request *http.Request) {
                        tpl.ExecuteTemplate(writer, tplName, nil)
                })
        }
}
...
func main() {
    ......
    http.Handle("/asset/", http.FileServer(http.Dir(".")))
        http.Handle("/resource/", http.FileServer(http.Dir(".")))
        registerView()
        log.Fatal(http.ListenAndServe(":8081", nil))
}

3.3 注册、登录和鉴权

package model
 
import "time"
 
const (
        SexWomen = "W"
        SexMan = "M"
        SexUnknown = "U"
)
 
type User struct {
        Id         int64     `xorm:"pk autoincr bigint(64)" form:"id" json:"id"`
        Mobile   string                 `xorm:"varchar(20)" form:"mobile" json:"mobile"`
        Passwd       string        `xorm:"varchar(40)" form:"passwd" json:"-"`   // 用户密码 md5(passwd + salt)
        Avatar           string                 `xorm:"varchar(150)" form:"avatar" json:"avatar"`
        Sex        string        `xorm:"varchar(2)" form:"sex" json:"sex"`
        Nickname    string        `xorm:"varchar(20)" form:"nickname" json:"nickname"`
        Salt       string        `xorm:"varchar(10)" form:"salt" json:"-"`
        Online     int        `xorm:"int(10)" form:"online" json:"online"`   //是否在线
        Token      string        `xorm:"varchar(40)" form:"token" json:"token"`   //用户鉴权
        Memo      string        `xorm:"varchar(140)" form:"memo" json:"memo"`
        Createat   time.Time        `xorm:"datetime" form:"createat" json:"createat"`   //创建时间, 统计用户增量时使用
}

我们user表中存储了用户名、密码、头像、用户性别、手机号等一些重要的信息，比较重要的是我们也存储了token标示用户在用户登录之后，http协议升级为websocket协议进行鉴权，这个细节点我们前边提到过，下边会有代码演示。

package model
 
import (
        "errors"
        "fmt"
        _ "github.com/go-sql-driver/mysql"
        "github.com/go-xorm/xorm"
        "log"
)
 
var DbEngine *xorm.Engine
 
func init() {
        driverName := "mysql"
        dsnName := "root:root@(127.0.0.1:3306)/chat?charset=utf8"
        err := errors.New("")
        DbEngine, err = xorm.NewEngine(driverName, dsnName)
        if err != nil && err.Error() != ""{
                log.Fatal(err)
        }
        DbEngine.ShowSQL(true)
        //设置数据库连接数
        DbEngine.SetMaxOpenConns(10)
        //自动创建数据库
        DbEngine.Sync(new(User), new(Community), new(Contact))
 
        fmt.Println("init database ok!")
}

我们创建一个DbEngine全局mysql连接对象，设置了一个大小为10的连接池。model包里的init函数在程序加载的时候会先执行，对Go语言熟悉的同学应该知道这一点。我们还设置了一些额外的参数用于调试程序，比如：设置打印运行中的sql，自动的同步数据表等，这些功能在生产环境中可以关闭。我们的model初始化工作就做完了，非常简陋，在实际的项目中，像数据库的用户名、密码、连接数和其他的配置信息，建议设置到配置文件中，然后读取，而不像本文硬编码的程序中。
注册是一个普通的api程序，对于Go语言来说，完成这件工作太简单了。
我们来看一下代码:

############################
//app/controller/user.go
############################
......
//用户注册
func UserRegister(writer http.ResponseWriter, request *http.Request) {
        var user model.User
        util.Bind(request, &user)
        user, err := UserService.UserRegister(user.Mobile, user.Passwd, user.Nickname, user.Avatar, user.Sex)
        if err != nil {
                util.RespFail(writer, err.Error())
        } else {
                util.RespOk(writer, user, "")
        }
}
......
############################
//app/service/user.go
############################
......
type UserService struct{}
 
//用户注册
func (s *UserService) UserRegister(mobile, plainPwd, nickname, avatar, sex string) (user model.User, err error) {
    registerUser := model.User{}
    _, err = model.DbEngine.Where("mobile=? ", mobile).Get(®isterUser)
    if err != nil {
            return registerUser, err
        }
        //如果用户已经注册,返回错误信息
        if registerUser.Id > 0 {
                return registerUser, errors.New("该手机号已注册")
        }
 
        registerUser.Mobile = mobile
        registerUser.Avatar = avatar
        registerUser.Nickname = nickname
        registerUser.Sex = sex
        registerUser.Salt = fmt.Sprintf("%06d", rand.Int31n(10000))
        registerUser.Passwd = util.MakePasswd(plainPwd, registerUser.Salt)
        registerUser.Createat = time.Now()
        //插入用户信息
        _, err = model.DbEngine.InsertOne(®isterUser)
 
        return registerUser,  err
}
......
############################
//main.go
############################
......
func main() {
    http.HandleFunc("/user/register", controller.UserRegister)
}

首先，我们使用util.Bind(request, &user)将用户参数绑定到user对象上，使用的是util包中的Bind函数，具体实现细节读者可以自行研究，主要模仿了Gin框架的参数绑定，可以拿来即用，非常方便。然后我们根据用户手机号搜索数据库中是否已经存在，如果不存在就插入到数据库中，返回注册成功信息，逻辑非常简单。
登录逻辑更简单：

############################
//app/controller/user.go
############################
...
//用户登录
func UserLogin(writer http.ResponseWriter, request *http.Request) {
        request.ParseForm()
 
        mobile := request.PostForm.Get("mobile")
        plainpwd := request.PostForm.Get("passwd")
 
        //校验参数
        if len(mobile) == 0 || len(plainpwd) == 0 {
                util.RespFail(writer, "用户名或密码不正确")
        }
 
        loginUser, err := UserService.Login(mobile, plainpwd)
        if err != nil {
                util.RespFail(writer, err.Error())
        } else {
                util.RespOk(writer, loginUser, "")
        }
}
...
############################
//app/service/user.go
############################
...
func (s *UserService) Login(mobile, plainpwd string) (user model.User, err error) {
        //数据库操作
        loginUser := model.User{}
        model.DbEngine.Where("mobile = ?", mobile).Get(&loginUser)
        if loginUser.Id == 0 {
                return loginUser, errors.New("用户不存在")
        }
        //判断密码是否正确
        if !util.ValidatePasswd(plainpwd, loginUser.Salt, loginUser.Passwd) {
                return loginUser, errors.New("密码不正确")
        }
        //刷新用户登录的token值
        token := util.GenRandomStr(32)
        loginUser.Token = token
        model.DbEngine.ID(loginUser.Id).Cols("token").Update(&loginUser)
 
        //返回新用户信息
        return loginUser, nil
}
...
############################
//main.go
############################
......
func main() {
    http.HandleFunc("/user/login", controller.UserLogin)
}

实现了登录逻辑，接下来我们就到了用户首页，这里列出了用户列表，点击即可进入聊天页面。用户也可以点击下边的tab栏查看自己所在的群组，可以由此进入群组聊天页面。
具体这些工作还需要读者自己开发用户列表、添加好友、创建群组、添加群组等功能，这些都是一些普通的api开发工作，我们的代码程序中也实现了，读者可以拿去修改使用，这里就不再演示了。
我们再重点看一下用户鉴权这一块吧，用户鉴权是指用户点击聊天进入聊天界面时，客户端会发送一个GET请求给服务端，请求建立一条websocket长连接，服务端收到建立连接的请求之后，会对客户端请求进行校验，以确实是否建立长连接，然后将这条长连接的句柄添加到map当中(因为服务端不仅仅对一个客户端服务，可能存在千千万万个长连接)维护起来。
我们下边来看具体代码实现：

############################
//app/controller/chat.go
############################
......
//本核心在于形成userid和Node的映射关系
type Node struct {
        Conn *websocket.Conn
        //并行转串行,
        DataQueue chan []byte
        GroupSets set.Interface
}
......
//userid和Node映射关系表
var clientMap map[int64]*Node = make(map[int64]*Node, 0)
//读写锁
var rwlocker sync.RWMutex
//实现聊天的功能
func Chat(writer http.ResponseWriter, request *http.Request) {
        query := request.URL.Query()
        id := query.Get("id")
        token := query.Get("token")
        userId, _ := strconv.ParseInt(id, 10, 64)
        //校验token是否合法
        islegal := checkToken(userId, token)
 
        conn, err := (&websocket.Upgrader{
                CheckOrigin: func(r *http.Request) bool {
                        return islegal
                },
        }).Upgrade(writer, request, nil)
 
        if err != nil {
                log.Println(err.Error())
                return
        }
        //获得websocket链接conn
        node := &Node{
                Conn:      conn,
                DataQueue: make(chan []byte, 50),
                GroupSets: set.New(set.ThreadSafe),
        }
 
        //获取用户全部群Id
        comIds := concatService.SearchComunityIds(userId)
        for _, v := range comIds {
                node.GroupSets.Add(v)
        }
 
        rwlocker.Lock()
        clientMap[userId] = node
        rwlocker.Unlock()
 
        //开启协程处理发送逻辑
        go sendproc(node)
 
        //开启协程完成接收逻辑
        go recvproc(node)
 
        sendMsg(userId, []byte("welcome!"))
}
 
......
 
//校验token是否合法
func checkToken(userId int64, token string) bool {
        user := UserService.Find(userId)
        return user.Token == token
}
 
......
 
############################
//main.go
############################
......
func main() {
    http.HandleFunc("/chat", controller.Chat)
}
......

进入聊天室，客户端发起/chat的GET请求，服务端首先创建了一个Node结构体，用来存储和客户端建立起来的websocket长连接句柄，每一个句柄都有一个管道DataQueue，用来收发信息，GroupSets是客户端对应的群组信息，后边我们会提到。

type Node struct {
        Conn *websocket.Conn
        //并行转串行,
        DataQueue chan []byte
        GroupSets set.Interface
}

服务端创建了一个map，将客户端用户id和其Node关联起来：

//userid和Node映射关系表
var clientMap map[int64]*Node = make(map[int64]*Node, 0)

接下来是主要的用户逻辑了，服务端接收到客户端的参数之后，首先校验token是否合法，由此确定是否要升级http协议到websocket协议，建立长连接，这一步称为鉴权。
代码如下：

//校验token是否合法
islegal := checkToken(userId, token)
 
conn, err := (&websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
                return islegal
        },
}).Upgrade(writer, request, nil)

鉴权成功以后，服务端初始化一个Node,搜索该客户端用户所在的群组id,填充到群组的GroupSets属性中。然后将Node节点添加到ClientMap中维护起来，我们对ClientMap的操作一定要加锁，因为Go语言在并发情况下，对map的操作并不保证原子安全。
代码如下：

//获得websocket链接conn
        node := &Node{
                Conn:      conn,
                DataQueue: make(chan []byte, 50),
                GroupSets: set.New(set.ThreadSafe),
        }
 
        //获取用户全部群Id
        comIds := concatService.SearchComunityIds(userId)
        for _, v := range comIds {
                node.GroupSets.Add(v)
        }
 
        rwlocker.Lock()
        clientMap[userId] = node
        rwlocker.Unlock()

服务端和客户端建立了长链接之后，会开启两个协程专门来处理客户端消息的收发工作，对于Go语言来说，维护协程的代价是很低的，所以说我们的单机程序可以很轻松的支持成千上完的用户聊天，这还是在没有优化的情况下。
代码如下：

......
//开启协程处理发送逻辑
        go sendproc(node)
 
        //开启协程完成接收逻辑
        go recvproc(node)
 
        sendMsg(userId, []byte("welcome!"))
......

至此，我们的鉴权工作也已经完成了，客户端和服务端的连接已经建立好了，接下来我们就来实现具体的聊天功能吧。

3.4 实现单聊和群聊

############################
//app/controller/chat.go
############################
type Message struct {
        Id      int64  `json:"id,omitempty" form:"id"`           //消息ID
        Userid  int64  `json:"userid,omitempty" form:"userid"`   //谁发的
        Cmd     int    `json:"cmd,omitempty" form:"cmd"`         //群聊还是私聊
        Dstid   int64  `json:"dstid,omitempty" form:"dstid"`     //对端用户ID/群ID
        Media   int    `json:"media,omitempty" form:"media"`     //消息按照什么样式展示
        Content string `json:"content,omitempty" form:"content"` //消息的内容
        Pic     string `json:"pic,omitempty" form:"pic"`         //预览图片
        Url     string `json:"url,omitempty" form:"url"`         //服务的URL
        Memo    string `json:"memo,omitempty" form:"memo"`       //简单描述
        Amount  int    `json:"amount,omitempty" form:"amount"`   //其他和数字相关的
}

每一条消息都有一个唯一的id，将来我们可以对消息持久化存储，但是我们系统中并没有做这件工作，读者可根据需要自行完成。然后是userid，发起消息的用户，对应的是dstid,要将消息发送给谁。
还有一个参数非常重要，就是cmd,它表示是群聊还是私聊，群聊和私聊的代码处理逻辑有所区别。
我们为此专门定义了一些cmd常量:

//定义命令行格式
const (
        CmdSingleMsg = 10
        CmdRoomMsg   = 11
        CmdHeart     = 0
)

• media是媒体类型，我们都知道微信支持语音、视频和各种其他的文件传输，我们设置了该参数之后，读者也可以自行拓展这些功能；

• content是消息文本，是聊天中最常用的一种形式；

• pic和url是为图片和其他链接资源所设置的；

• memo是简介；

• amount是和数字相关的信息，比如说发红包业务有可能使用到该字段。

############################
//app/controller/chat.go
############################
......
//发送逻辑
func sendproc(node *Node) {
        for {
                select {
                case data := <-node.DataQueue:
                        err := node.Conn.WriteMessage(websocket.TextMessage, data)
                        if err != nil {
                                log.Println(err.Error())
                                return
                        }
                }
        }
}
 
//接收逻辑
func recvproc(node *Node) {
        for {
                _, data, err := node.Conn.ReadMessage()
                if err != nil {
                        log.Println(err.Error())
                        return
                }
 
                dispatch(data)
                //todo对data进一步处理
                fmt.Printf("recv<=%s", data)
        }
}
......
//后端调度逻辑处理
func dispatch(data []byte) {
        msg := Message{}
        err := json.Unmarshal(data, &msg)
        if err != nil {
                log.Println(err.Error())
                return
        }
        switch msg.Cmd {
        case CmdSingleMsg:
                sendMsg(msg.Dstid, data)
        case CmdRoomMsg:
                for _, v := range clientMap {
                        if v.GroupSets.Has(msg.Dstid) {
                                v.DataQueue <- data
                        }
                }
        case CmdHeart:
                //检测客户端的心跳
        }
}
 
//发送消息,发送到消息的管道
func sendMsg(userId int64, msg []byte) {
        rwlocker.RLock()
        node, ok := clientMap[userId]
        rwlocker.RUnlock()
        if ok {
                node.DataQueue <- msg
        }
}
......

服务端向客户端发送消息逻辑比较简单，就是将客户端发送过来的消息，直接添加到目标用户Node的channel中去就好了。
通过websocket的WriteMessage就可以实现此功能：

func sendproc(node *Node) {
        for {
                select {
                case data := <-node.DataQueue:
                        err := node.Conn.WriteMessage(websocket.TextMessage, data)
                        if err != nil {
                                log.Println(err.Error())
                                return
                        }
                }
        }
}

收发逻辑是这样的，服务端通过websocket的ReadMessage方法接收到用户信息，然后通过dispatch方法进行调度：

func recvproc(node *Node) {
        for {
                _, data, err := node.Conn.ReadMessage()
                if err != nil {
                        log.Println(err.Error())
                        return
                }
 
                dispatch(data)
                //todo对data进一步处理
                fmt.Printf("recv<=%s", data)
        }
}

dispatch方法所做的工作有两件：

• 1）解析消息体到Message中；

• 2）根据消息类型，将消息体添加到不同用户或者用户组的channel当中。

func dispatch(data []byte) {
        msg := Message{}
        err := json.Unmarshal(data, &msg)
        if err != nil {
                log.Println(err.Error())
                return
        }
        switch msg.Cmd {
        case CmdSingleMsg:
                sendMsg(msg.Dstid, data)
        case CmdRoomMsg:
                for _, v := range clientMap {
                        if v.GroupSets.Has(msg.Dstid) {
                                v.DataQueue <- data
                        }
                }
        case CmdHeart:
                //检测客户端的心跳
        }
}
......
func sendMsg(userId int64, msg []byte) {
        rwlocker.RLock()
        node, ok := clientMap[userId]
        rwlocker.RUnlock()
        if ok {
                node.DataQueue <- msg
        }
}

3.5 发送表情和图片

{
"dstid":1,
"cmd":10,
"userid":2,
"media":4,
"url":"/asset/plugins/doutu//emoj/2.gif"
}

客户端拿到url后，就加载本地的小图标。
聊天中用户发送图片也是一样的原理，不过聊天中用户的图片需要先上传到服务器，然后服务端返回url，客户端再进行加载，我们的IM系统也支持此功能。
我们看一下图片上传的程序：

############################
//app/controller/upload.go
############################
func init() {
        os.MkdirAll("./resource", os.ModePerm)
}
 
func FileUpload(writer http.ResponseWriter, request *http.Request) {
        UploadLocal(writer, request)
}
 
//将文件存储在本地/im_resource目录下
func UploadLocal(writer http.ResponseWriter, request *http.Request) {
        //获得上传源文件
        srcFile, head, err := request.FormFile("file")
        if err != nil {
                util.RespFail(writer, err.Error())
        }
        //创建一个新的文件
        suffix := ".png"
        srcFilename := head.Filename
        splitMsg := strings.Split(srcFilename, ".")
        if len(splitMsg) > 1 {
                suffix = "." + splitMsg[len(splitMsg)-1]
        }
        filetype := request.FormValue("filetype")
        if len(filetype) > 0 {
                suffix = filetype
        }
        filename := fmt.Sprintf("%d%s%s", time.Now().Unix(), util.GenRandomStr(32), suffix)
        //创建文件
        filepath := "./resource/" + filename
        dstfile, err := os.Create(filepath)
        if err != nil {
                util.RespFail(writer, err.Error())
                return
        }
        //将源文件拷贝到新文件
        _, err = io.Copy(dstfile, srcFile)
        if err != nil {
                util.RespFail(writer, err.Error())
                return
        }
 
        util.RespOk(writer, filepath, "")
}
......
############################
//main.go
############################
func main() {
    http.HandleFunc("/attach/upload", controller.FileUpload)
}

我们将文件存放到本地的一个磁盘文件夹下，然后发送给客户端路径，客户端通过路径加载相关的图片信息。
关于发送图片，我们虽然实现功能，但是做的太简单了，我们在接下来的章节详细的和大家探讨一下系统优化相关的方案。怎样让我们的系统在生产环境中用的更好。

4、程序优化和系统架构升级方案

4.1 代码优化

• 1）我们可以将鉴权做的更好，使用wss://代替ws://；

• 2）在一些安全领域，可以对消息体进行加密，在高并发领域，可以对消息体进行压缩；

• 3）对Mysql连接池再做优化，将消息持久化存储到mongo，避免对数据库频繁的写入，将单条写入改为多条一块写入；

• 4）为了使程序耗费更少的CPU，降低对消息体进行Json编码的次数，一次编码，多次使用......

4.2 系统架构升级

5、本文结语

6、相关文章

因无法直接引用外链，本文引用的技术文章链接如下：

[1]《新手入门一篇就够：从零开发移动端IM》：

http://www.52im.net/thread-464-1-1.html

[2]《自已开发IM有那么难吗？手把手教你自撸一个Andriod版简易IM (有源码)》：

http://www.52im.net/thread-2671-1-1.html

[3]《拿起键盘就是干：跟我一起徒手开发一套分布式IM系统》：

http://www.52im.net/thread-2775-1-1.html

[4]《适合新手：从零开发一个IM服务端（基于Netty，有完整源码）》：

http://www.52im.net/thread-2768-1-1.html

[5]《12306抢票带来的启示：看我如何用Go实现百万QPS的秒杀系统(含源码)》：

http://www.52im.net/thread-2771-1-1.html