共计 9069 个字符，预计需要花费 23 分钟才能阅读完成。
本文由作者“大白菜”分享，有较多订正和改变。留神：本系列是给 IM 初学者的文章，IM 老油条们还望海涵，勿喷！
1、引言
接上篇《IM 零碎设计篇》，本篇次要解说的是通过实战编码实现 IM 的单聊性能，内容波及技术原理、编码实际。
补充阐明：因为本系列文章次要目标是疏导 IM 初学者在基于 Netty 的状况下，如何一步一步从零写出 IM 的逻辑和思维能力，因此为了简化编码实现，本系列中编码实现的客户端都是基于控制台实现的（心愿不要被厌弃），因为了解技术的实质显然比炫酷的外在表现形式更为重要。
学习交换：
- 挪动端 IM 开发入门文章：《新手入门一篇就够：从零开发挪动端 IM》
- 开源 IM 框架源码：https://github.com/JackJiang2…（备用地址点此）
（本文已同步公布于：http://www.52im.net/thread-39…）
2、写在后面
倡议你在浏览本文之前，务必先读本系列首篇《IM 零碎设计篇》，在着重了解 IM 零碎的实践设计思路之后，再来读实战代码则成果更好。
最初，在开始本文之前，请您务必提前理解 Netty 的相干基础知识，可从本系列首篇《IM 零碎设计篇》中的“常识筹备”一章开始。
3、系列文章
本文是系列文章的第 2 篇，以下是系列目录：
《基于 Netty，从零开发 IM(一)：IM 零碎设计篇》
《基于 Netty，从零开发 IM(二)：编码实际篇（单聊性能）》（* 本文）
《基于 Netty，从零开发 IM(三)：编码实际篇（群聊性能）》（稍后公布..）
《基于 Netty，从零开发 IM(四)：编码实际篇（系统优化）》（稍后公布..）
4、运行成果
本篇咱们次要来实现的是 IM 单聊性能，具体就是：模仿 IM 聊天的两个用户别离登陆各自的账号，而后能够相互发送聊天音讯。
咱们提前看一下本篇要实现的性能运行成果。
客户端 1 登陆成果：
客户端 2 登陆成果：
客户端 1 发送音讯效果图：
客户端 2 承受音讯效果图：
5、技术原理
5.1 概述
上节中，能够看到此次实战的运行成果是一个基于 console 控制台的聊天，依据上篇《IM 零碎设计篇》的思路设计，咱们也晓得次要外围是服务端保留一份关系映射，通过承受人 ID 找到对应的通道进行音讯发送。
然而，咱们要想实现具体的性能，则须要大体上做一个核心技术实现步骤的拆解，具体拆分成以下三步。
5.2 第一步：编码和解码的实现
针对 IM 单聊性能，有两个核心技术点：
1）一是序列化和反序列化；
2）二是通信协定实现。
客户端和服务端之间的数据通讯，咱们是基于实体对象去交互的，这样数据格式更加的不便。
对于实体对象的序列化和反序列化，举荐应用 Fastjson 框架去实现，而不是 Netty 官网示例所应用的对象流。
同时为了更加标准的治理不同业务实体，咱们须要定义一个实体基类，所有的业务实体都继承它（上面的章节会具体解说）。
5.3 第二步：登录和音讯发送两个业务点的实现
登录次要是为了让用户 ID 和通道（就是 Netty 中的 Channel，也即网络连接）进行绑定。
在登录胜利之后为 Channel 通过 attr() 办法绑定该用户 ID，次要目标有三个：
1）客户端 A 在发送音讯时，服务端能够通过 Channel 获取音讯发送者的用户 ID，以便晓得音讯是“谁”发过来的；
2）服务端在收到客户端 A 发过来的音讯时，通过音讯中的接收者用户 ID，能够获取接收者的 Channel，以便晓得音讯该发给“谁”；
3）在 Channel 断开的时候，服务端能够监听到 Channel，并且获取 Channel 的属性，从而删除对应的用户 ID 和 Chennel 映射关系。
对于业务解决来说，用户登录和音讯发送是两个不同的业务点，一般来说须要定义多个 Handler 来别离解决，然而这里为了缩小 Handler 的数量，对立一个 Handler 解决。
- 情谊提醒：用户 ID 和 Chennel 的绑定，能够参考成熟的开源 IM 工程 MobileIMSDK 中的实现逻辑 OnlineProcessor.java，以便通过更靠近 IM 产品级实际进行学习。
5.4 第三步：映射关系的实现
后面也剖析过了，服务端须要保留一份用户 ID 和 Channel 映射关系，这个映射关系只须要应用一个 Map 进行存储即可，即 Map<Integer,Channel>，其中：key 是用户 ID、value 是 Channel（Channel 也就是客户端的网络连接对象啦）。
这部分须要交待的不多，了解分明用户 ID 和 Channel 的关系就足够了。
接下来就是具体的编码实战了。。。
6、实体定义实战
实体的设计，次要从两个方面进行动手思考：
1）通信协定的规定，别离是协定标识符、业务指令、数据长度、数据四个局部；
2）不同业务对应不同的字段属性。
具体如下图所示：
根底实体：
次要定义 tag 字段，标识协定的标识符，code () 形象办法，次要示意的是业务指令，不同的业务对应不同的指令。
@Data
public abstract class BaseBean implements Serializable {
private Integer tag=1;// 固定值，标识的是一个协定类型，不同协定对应不同的值
public abstract Byte code();// 业务指令形象办法}
登录申请实体：
@Data
public class LoginReqBean extends BaseBean implements Serializable {
private Integer userid;// 用户 ID
private String username;// 用户名称
public Byte code() {return 1;// 业务指令}
}
登录响应实体：
@Data
public class LoginResBean extends BaseBean implements Serializable {
private Integer status;// 响应状态，0 登录胜利，1 登录失败
private String msg;// 响应信息
private Integer userid;// 用户 ID
public Byte code() {return 2;// 业务指令}
}
音讯发送实体：
public class MsgReqBean extends BaseBean implements Serializable {
private Integer fromuserid;// 发送人 ID
private Integer touserid;// 承受人 ID
private String msg;// 发送音讯
public Byte code() {return 3;// 业务指令}
}
音讯响应响应：
public class MsgResBean extends BaseBean implements Serializable {
private Integer status;// 响应状态，0 发送胜利，1 发送失败
private String msg;// 响应信息
public Byte code() {return 4;// 业务指令}
}
音讯承受实体：
public class MsgRecBean extends BaseBean implements Serializable {
private Integer fromuserid;// 发送人 ID
private String msg;// 音讯
public Byte code() {return 5;// 业务指令}
}
7、编码和解码实战
7.1 依赖坐标
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
7.2 编码实现
public class MyEncoder extends MessageToByteEncoder<BaseBean> {
protected void encode(
ChannelHandlerContext channelHandlerContext,
BaseBean baseBean,
ByteBuf byteBuf) throws Exception {
//1. 把实体序列化成字节数字
byte[] bytes= JSON.toJSONBytes(baseBean);
//2. 依据协定组装数据
byteBuf.writeInt(baseBean.getTag());// 标识（4 个字节）byteBuf.writeByte(baseBean.code());// 指令（1 个字节）byteBuf.writeInt(bytes.length);// 长度（4 个字节）byteBuf.writeBytes(bytes);//
}
}
7.3 解码实现
public class MyDecoder extends ByteToMessageDecoder {
protected void decode(
ChannelHandlerContext channelHandlerContext,
ByteBuf byteBuf,
List<Object> list) throws Exception {
//1. 依据协定取出数据
int tag=byteBuf.readInt();// 标识符
byte code=byteBuf.readByte();// 获取指令
int len=byteBuf.readInt();// 获取数据长度
byte[] bytes=new byte[len];
byteBuf.readBytes(bytes);
//2. 依据 code 获取类型
Class<? extendsBaseBean> c= MapUtils.getBean(code);
//3. 反序列化
BaseBean baseBean=JSON.parseObject(bytes,c);
list.add(baseBean);
}
}
7.4 指令和实体关系
为什么须要这么一个工具类呢？指令示意的是业务类型，不同的业务对应不同的实体，那么解码的时候，怎么晓得反序列化成什么样的实体呢？思路是获取到的指令，再依据指令找到对应的实体即可。
public class MapUtils {
//1. 自定义指令
private static Byte codeLoginReq=1;
private static Byte codeLoginRes=2;
private static Byte codeMsgReq=3;
private static Byte codeMsgRes=4;
private static Byte codeMsgRec=5;
//2. 自定义一个 Map，专门治理指令和实体的关系
private static Map<Byte, Class<? extends BaseBean>> map=new HashMap<Byte,Class<? extends BaseBean>>();
//3. 初始化
static{map.put(codeLoginReq, LoginReqBean.class);
map.put(codeLoginRes, LoginResBean.class);
map.put(codeMsgReq, MsgReqBean.class);
map.put(codeMsgRes, MsgResBean.class);
map.put(codeMsgRec, MsgRecBean.class);
}
//4. 依据指令获取对应的实体
public static Class<? extends BaseBean> getBean(Byte code){
try{return map.get(code);
}catch(Exception e){throw new RuntimeException(e.getMessage());
}
}
}
8、客户端代码实战
8.1 Pipeline 治理链表
.handler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) {
//1. 拆包器
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,5,4));
//2. 自定义解码器
ch.pipeline().addLast(new MyDecoder());
//3. 自定义业务
ch.pipeline().addLast(new ClientChatHandler());
//4. 自定义编码器
ch.pipeline().addLast(new MyEncoder());
}
});
8.2 业务 Handler
所有的业务解决在同一个 Handler 外面进行解决，通过判断实体类型来辨别不同的业务解决。
public class ClientChatHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// 通道就绪时，发动登录申请
login(ctx.channel());
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 依据 msg 做类型判断，不同的业务做不同的解决
if(msg instanceof LoginResBean){
//1. 登录后果响应
LoginResBean res=(LoginResBean) msg;
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 登录响应："+res.getMsg());
if(res.getStatus()==0){
//1. 登录胜利，则给通道绑定属性
ctx.channel().attr(AttributeKey.valueOf("userid")).set(res.getUserid());
//2. 调用发送音讯办法
sendMsg(ctx.channel());
}else{
//1. 登录失败，调用登录办法
login(ctx.channel());
}
}elseif(msg instanceof MsgResBean){
//1. 发送音讯后果响应
MsgResBean res=(MsgResBean)msg;
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 发送响应："+res.getMsg());
}else if(msg instanceof MsgRecBean){
//2. 承受音讯
MsgRecBean res=(MsgRecBean)msg;
System.out.println("fromuserid="+res.getFromuserid()+",msg="+res.getMsg());
}
}
// 登录办法
private void login(Channel channel){Scanner scanner=new Scanner(System.in);
System.out.println(">> 用户 ID：");
Integer userid=scanner.nextInt();
System.out.println(">> 用户名称：");
String username=scanner.next();
LoginReqBean bean=new LoginReqBean();
bean.setUserid(userid);
bean.setUsername(username);
channel.writeAndFlush(bean);
}
// 发送音讯办法
private void sendMsg(finalChannel channel){final Scanner scanner=new Scanner(System.in);
new Thread(new Runnable() {public void run() {while(true){System.out.println(">> 接管人 ID：");
Integer touserid=scanner.nextInt();
System.out.println(">> 聊天内容：");
String msg=scanner.next();
MsgReqBean bean=new MsgReqBean();
// 从通道属性获取发送人 ID
Integer fromuserid=(Integer) channel.attr(AttributeKey.valueOf("userid")
).get();
// 发送人 ID
bean.setFromuserid(fromuserid);
// 承受人 ID
bean.setTouserid(touserid);
// 发送音讯
bean.setMsg(msg);
channel.writeAndFlush(bean);
}
}
}).start();}
}
9、服务端代码实战
9.1 Pipeline 治理链表
.childHandler(new ChannelInitializer<NioSocketChannel>() {
protected void initChannel(NioSocketChannel ch) {
//1. 拆包器
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,5,4));
//2. 自定义解码器
ch.pipeline().addLast(new MyDecoder());
//3. 业务 Handler
ch.pipeline().addLast(new ServerChatHandler());
//4. 自定义编码器
ch.pipeline().addLast(new MyEncoder());
}
});
9.2 业务 Handler
public class ServerChatHandler extends ChannelInboundHandlerAdapter{
//1. 定义一个 Map（key 是用户 ID，value 是连贯通道）private static Map<Integer, Channel> map=new HashMap<Integer, Channel>();
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {if(msg instanceof LoginReqBean){
//1. 登录申请
login((LoginReqBean) msg,ctx.channel());
}else if(msg instanceof MsgReqBean){
//2. 发送音讯申请
sendMsg((MsgReqBean)msg,ctx.channel());
}
}
// 登录解决办法
private void login(LoginReqBean bean, Channel channel){LoginResBean res=new LoginResBean();
// 从 map 外面依据用户 ID 获取连贯通道
Channel c=map.get(bean.getUserid());
if(c==null){
// 通道为空，证实该用户没有在线
//1. 增加到 map
map.put(bean.getUserid(),channel);
//2. 给通道赋值
channel.attr(AttributeKey.valueOf("userid")).set(bean.getUserid());
//3. 响应
res.setStatus(0);
res.setMsg("登录胜利");
res.setUserid(bean.getUserid());
channel.writeAndFlush(res);
}else{
// 通道不为空，证实该用户曾经在线了
res.setStatus(1);
res.setMsg("该账户目前在线");
channel.writeAndFlush(res);
}
}
// 音讯发送解决办法
private void sendMsg(MsgReqBean bean,Channel channel){Integer touserid=bean.getTouserid();
Channel c=map.get(touserid);
if(c==null){MsgResBean res=new MsgResBean();
res.setStatus(1);
res.setMsg(touserid+", 不在线");
channel.writeAndFlush(res);
}else{MsgRecBean res=new MsgRecBean();
res.setFromuserid(bean.getFromuserid());
res.setMsg(bean.getMsg());
c.writeAndFlush(res);
}
}
}
10、本篇小结
本篇次要编码实战了 IM 的单聊性能，实现思路绝对还是略微有点小简单。
大家次要外围把握以下几点思路就能够了：
1）不同的业务可设置不同的实体和指令，须要把指令和实体的关系治理起来，不便反序列化的时候，能够依据指令来反序列化到具体实体；
2）须要把用户 ID 和通道的关系治理起来（不便依据用户 ID 找到 Channel 通道，反过来也一样），并且灵活运用 Channel 的 attr () 办法，该办法能够绑定属性值，十分的有用。
11、参考资料
[1] 手把手教你用 Netty 实现心跳机制、断线重连机制
[2] 自已开发 IM 很难？手把手教你撸一个 Andriod 版 IM
[3] 基于 Netty，从零开发一个 IM 服务端
[4] 拿起键盘就是干，教你徒手开发一套分布式 IM 零碎
[5] 正确理解 IM 长连贯、心跳及重连机制，并入手实现
[6] 手把手教你用 Go 疾速搭建高性能、可扩大的 IM 零碎
[7] 手把手教你用 WebSocket 打造 Web 端 IM 聊天
[8] 万字长文，手把手教你用 Netty 打造 IM 聊天
[9] 基于 Netty 实现一套分布式 IM 零碎
[10] 基于 Netty，搭建高性能 IM 集群（含技术思路 + 源码）
[11] SpringBoot 集成开源 IM 框架 MobileIMSDK，实现即时通讯 IM 聊天性能
（本文已同步公布于：http://www.52im.net/thread-39…）