netty 自定义通讯协议

Netty中，通讯的双方建立连接后，会把数据按照ByteBuf的方式进行传输，例如http协议中，就是通过HttpRequestDecoder对ByteBuf数据流进行处理，转换成http的对象。基于这个思路，我自定义一种通讯协议：Server和客户端直接传输java对象。

实现的原理是通过Encoder把java对象转换成ByteBuf流进行传输，通过Decoder把ByteBuf转换成java对象进行处理，处理逻辑如下图所示：

传输的java bean为Person：

1. package com.guowl.testobjcoder;
2. import java.io.Serializable;
3. // 必须实现Serializable接口
4. public class Person implements Serializable{
5. private static final long   serialVersionUID    = 1L;
6. private String  name;
7. private String  sex;
8. private int     age;
9. public String toString() {
10. return "name:" + name + " sex:" + sex + " age:" + age;
11. }
12. public String getName() {
13. return name;
14. }
15. public void setName(String name) {
16. this.name = name;
17. }
18. public String getSex() {
19. return sex;
20. }
21. public void setSex(String sex) {
22. this.sex = sex;
23. }
24. public int getAge() {
25. return age;
26. }
27. public void setAge(int age) {
28. this.age = age;
29. }
30. }

Server端类：Server PersonDecoder BusinessHandler

1、Server：启动netty服务

1. package com.guowl.testobjcoder;
2. import io.netty.bootstrap.ServerBootstrap;
3. import io.netty.channel.ChannelFuture;
4. import io.netty.channel.ChannelInitializer;
5. import io.netty.channel.ChannelOption;
6. import io.netty.channel.EventLoopGroup;
7. import io.netty.channel.nio.NioEventLoopGroup;
8. import io.netty.channel.socket.SocketChannel;
9. import io.netty.channel.socket.nio.NioServerSocketChannel;
10. public class Server {
11. public void start(int port) throws Exception {
12. EventLoopGroup bossGroup = new NioEventLoopGroup();
13. EventLoopGroup workerGroup = new NioEventLoopGroup();
14. try {
15. ServerBootstrap b = new ServerBootstrap();
16. b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
17. .childHandler(new ChannelInitializer<SocketChannel>() {
18. @Override
19. public void initChannel(SocketChannel ch) throws Exception {
20. ch.pipeline().addLast(new PersonDecoder());
21. ch.pipeline().addLast(new BusinessHandler());
22. }
23. }).option(ChannelOption.SO_BACKLOG, 128)
24. .childOption(ChannelOption.SO_KEEPALIVE, true);
25. ChannelFuture f = b.bind(port).sync();
26. f.channel().closeFuture().sync();
27. } finally {
28. workerGroup.shutdownGracefully();
29. bossGroup.shutdownGracefully();
30. }
31. }
32. public static void main(String[] args) throws Exception {
33. Server server = new Server();
34. server.start(8000);
35. }
36. }

2、PersonDecoder：把ByteBuf流转换成Person对象，其中ByteBufToBytes是读取ButeBuf的工具类，上一篇文章中提到过，在此不在详述。ByteObjConverter是byte和obj的互相转换的工具。

1. package com.guowl.testobjcoder;
2. import io.netty.buffer.ByteBuf;
3. import io.netty.channel.ChannelHandlerContext;
4. import io.netty.handler.codec.ByteToMessageDecoder;
5. import java.util.List;
6. import com.guowl.utils.ByteBufToBytes;
7. import com.guowl.utils.ByteObjConverter;
8. public class PersonDecoder extends ByteToMessageDecoder {
9. @Override
10. protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
11. ByteBufToBytes read = new ByteBufToBytes();
12. Object obj = ByteObjConverter.ByteToObject(read.read(in));
13. out.add(obj);
14. }
15. }

3、BusinessHandler 读取Person信息，并打印

1. package com.guowl.testobjcoder;
2. import io.netty.channel.ChannelHandlerContext;
3. import io.netty.channel.ChannelInboundHandlerAdapter;
4. import org.slf4j.Logger;
5. import org.slf4j.LoggerFactory;
6. public class BusinessHandler extends ChannelInboundHandlerAdapter {
7. private Logger  logger  = LoggerFactory.getLogger(BusinessHandler.class);
8. @Override
9. public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
10. Person person = (Person) msg;
11. logger.info("BusinessHandler read msg from client :" + person);
12. }
13. @Override
14. public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
15. ctx.flush();
16. }
17. @Override
18. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
19. }
20. }

Client端的类：Client ClientInitHandler PersonEncoder

1、Client 建立与Server的连接

1. package com.guowl.testobjcoder;
2. import io.netty.bootstrap.Bootstrap;
3. import io.netty.channel.ChannelFuture;
4. import io.netty.channel.ChannelInitializer;
5. import io.netty.channel.ChannelOption;
6. import io.netty.channel.EventLoopGroup;
7. import io.netty.channel.nio.NioEventLoopGroup;
8. import io.netty.channel.socket.SocketChannel;
9. import io.netty.channel.socket.nio.NioSocketChannel;
10. public class Client {
11. public void connect(String host, int port) throws Exception {
12. EventLoopGroup workerGroup = new NioEventLoopGroup();
13. try {
14. Bootstrap b = new Bootstrap();
15. b.group(workerGroup);
16. b.channel(NioSocketChannel.class);
17. b.option(ChannelOption.SO_KEEPALIVE, true);
18. b.handler(new ChannelInitializer<SocketChannel>() {
19. @Override
20. public void initChannel(SocketChannel ch) throws Exception {
21. ch.pipeline().addLast(new PersonEncoder());
22. ch.pipeline().addLast(new ClientInitHandler());
23. }
24. });
25. ChannelFuture f = b.connect(host, port).sync();
26. f.channel().closeFuture().sync();
27. } finally {
28. workerGroup.shutdownGracefully();
29. }
30. }
31. public static void main(String[] args) throws Exception {
32. Client client = new Client();
33. client.connect("127.0.0.1", 8000);
34. }
35. }

2、ClientInitHandler 向Server发送Person对象

1. package com.guowl.testobjcoder;
2. import io.netty.channel.ChannelHandlerContext;
3. import io.netty.channel.ChannelInboundHandlerAdapter;
4. import org.slf4j.Logger;
5. import org.slf4j.LoggerFactory;
6. public class ClientInitHandler extends ChannelInboundHandlerAdapter {
7. private static Logger   logger  = LoggerFactory.getLogger(ClientInitHandler.class);
8. @Override
9. public void channelActive(ChannelHandlerContext ctx) throws Exception {
10. logger.info("HelloClientIntHandler.channelActive");
11. Person person = new Person();
12. person.setName("guowl");
13. person.setSex("man");
14. person.setAge(30);
15. ctx.write(person);
16. ctx.flush();
17. }
18. }

3、PersonEncoder 把Person对象转换成ByteBuf进行传送

1. package com.guowl.testobjcoder;
2. import com.guowl.utils.ByteObjConverter;
3. import io.netty.buffer.ByteBuf;
4. import io.netty.channel.ChannelHandlerContext;
5. import io.netty.handler.codec.MessageToByteEncoder;
6. public class PersonEncoder extends MessageToByteEncoder<Person> {
7. @Override
8. protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
9. byte[] datas = ByteObjConverter.ObjectToByte(msg);
10. out.writeBytes(datas);
11. ctx.flush();
12. }
13. }

工具类：ByteObjConverter

1. package com.guowl.utils;
2. import java.io.ByteArrayInputStream;
3. import java.io.ByteArrayOutputStream;
4. import java.io.IOException;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
7. public class ByteObjConverter {
8. public static Object ByteToObject(byte[] bytes) {
9. Object obj = null;
10. ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
11. ObjectInputStream oi = null;
12. try {
13. oi = new ObjectInputStream(bi);
14. obj = oi.readObject();
15. } catch (Exception e) {
16. e.printStackTrace();
17. } finally {
18. try {
19. bi.close();
20. } catch (IOException e) {
21. e.printStackTrace();
22. }
23. try {
24. oi.close();
25. } catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29. return obj;
30. }
31. public static byte[] ObjectToByte(Object obj) {
32. byte[] bytes = null;
33. ByteArrayOutputStream bo = new ByteArrayOutputStream();
34. ObjectOutputStream oo = null;
35. try {
36. oo = new ObjectOutputStream(bo);
37. oo.writeObject(obj);
38. bytes = bo.toByteArray();
39. } catch (Exception e) {
40. e.printStackTrace();
41. } finally {
42. try {
43. bo.close();
44. } catch (IOException e) {
45. e.printStackTrace();
46. }
47. try {
48. oo.close();
49. } catch (IOException e) {
50. e.printStackTrace();
51. }
52. }
53. return (bytes);
54. }
55. }

通过上述代码，实现了Server端与Client端直接使用person对象进行通信的目的。基于此，可以构建更为复杂的场景：Server端同时支撑多种协议，不同的协议采用不同的Decoder进行解析，解析结果保持统一，这样业务处理类可以保持接口一致。下一节将编写这样一个案例。

本例中需要注意的事项是：

1、Person对象必须实现Serializable接口，否则不能进行序列化。

2、PersonDecoder读取ByteBuf数据的时候，并没有对多次流式数据进行处理，而是简单的一次性接收，如果数据量大的情况下，可能会出现数据不完整，这个问题会在后续的学习中解决。