首页 > 代码库 > Mina、Netty、Twisted一起学(四):定制自己的协议
Mina、Netty、Twisted一起学(四):定制自己的协议
在前面的博文中,介绍一些消息分割的方案,以及MINA、Netty、Twisted针对这些方案提供的相关API。例如MINA的TextLineCodecFactory、PrefixedStringCodecFactory,Netty的LineBasedFrameDecoder、LengthFieldBasedFrameDecoder,Twisted的LineOnlyReceiver、Int32StringReceiver。
除了这些方案,还有很多其他方案,当然也可以自己定义。在这里,我们定制一个自己的方案,并分别使用MINA、Netty、Twisted实现对这种消息的解析和组装,也就是编码和解码。
上一篇博文中介绍了一种用固定字节数的Header来指定Body字节数的消息分割方案,其中Header部分是常规的大字节序(Big-Endian)的4字节整数。本文中对这个方案稍作修改,将固定字节数的Header改为小字节序(Little-Endian)的4字节整数。
常规的大字节序表示一个数的话,用高字节位的存放数字的低位,比较符合人的习惯。而小字节序和大字节序正好相反,用高字节位存放数字的高位。
Python中struct模块支持大小字节序的pack和unpack,在Java中可以用下面的两个方法实现小字节序字节数组转int和int转小字节序字节数组,下面的Java程序中将会用到这两个方法:
public class LittleEndian { /** * 将int转成4字节的小字节序字节数组 */ public static byte[] toLittleEndian(int i) { byte[] bytes = new byte[4]; bytes[0] = (byte) i; bytes[1] = (byte) (i >>> 8); bytes[2] = (byte) (i >>> 16); bytes[3] = (byte) (i >>> 24); return bytes; } /** * 将小字节序的4字节的字节数组转成int */ public static int getLittleEndianInt(byte[] bytes) { int b0 = bytes[0] & 0xFF; int b1 = bytes[1] & 0xFF; int b2 = bytes[2] & 0xFF; int b3 = bytes[3] & 0xFF; return b0 + (b1 << 8) + (b2 << 16) + (b3 << 24); } }
无论是MINA、Netty还是Twisted,消息的编码、解码、切合的代码,都是应该和业务逻辑代码分开,这样有利于代码的开发、重用和维护。在MINA和Netty中类似,编码、解码需要继承实现相应的Encoder、Decoder,而在Twisted中则是继承Protocol实现编码解码。虽然实现方式不同,但是它们的功能都是一样的:
1、对消息根据一定规则进行切合,例如固定长度消息、按行、按分隔符、固定长度Header指定Body长度等;
2、将切合后的消息由字节码转成自己想要的类型,如MINA中将IoBuffer转成字符串,这样messageReceived接收到的message参数就是String类型;
3、write的时候可以传入自定义类型的参数,由编码器完成编码。
下面分别用MINA、Netty、Twisted实现4字节的小字节序int来指定body长度的消息的编码解码。
MINA:
在MINA中对接收到的消息进行切合和解码,一般会定义一个解码器类,继承自抽象类CumulativeProtocolDecoder,实现doDecode方法:
public class MyMinaDecoder extends CumulativeProtocolDecoder { @Override protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception { // 如果没有接收完Header部分(4字节),直接返回false if(in.remaining() < 4) { return false; } else { // 标记开始位置,如果一条消息没传输完成则返回到这个位置 in.mark(); byte[] bytes = new byte[4]; in.get(bytes); // 读取4字节的Header int bodyLength = LittleEndian.getLittleEndianInt(bytes); // 按小字节序转int // 如果body没有接收完整,直接返回false if(in.remaining() < bodyLength) { in.reset(); // IoBuffer position回到原来标记的地方 return false; } else { byte[] bodyBytes = new byte[bodyLength]; in.get(bodyBytes); String body = new String(bodyBytes, "UTF-8"); out.write(body); // 解析出一条消息 return true; } } } }
另外,session.write的时候要对数据编码,需要定义一个编码器,继承自抽象类ProtocolEncoderAdapter,实现encode方法:
public class MyMinaEncoder extends ProtocolEncoderAdapter { @Override public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception { String msg = (String) message; byte[] bytes = msg.getBytes("UTF-8"); int length = bytes.length; byte[] header = LittleEndian.toLittleEndian(length); // 按小字节序转成字节数组 IoBuffer buffer = IoBuffer.allocate(length + 4); buffer.put(header); // header buffer.put(bytes); // body buffer.flip(); out.write(buffer); } }
在服务器启动的时候加入相应的编码器和解码器:
public class TcpServer { public static void main(String[] args) throws IOException { IoAcceptor acceptor = new NioSocketAcceptor(); // 指定编码解码器 acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MyMinaEncoder(), new MyMinaDecoder())); acceptor.setHandler(new TcpServerHandle()); acceptor.bind(new InetSocketAddress(8080)); } }
下面是业务逻辑的代码:
public class TcpServerHandle extends IoHandlerAdapter { @Override public void exceptionCaught(IoSession session, Throwable cause) throws Exception { cause.printStackTrace(); } // 接收到新的数据 @Override public void messageReceived(IoSession session, Object message) throws Exception { // MyMinaDecoder将接收到的数据由IoBuffer转为String String msg = (String) message; System.out.println("messageReceived:" + msg); // MyMinaEncoder将write的字符串添加了一个小字节序Header并转为字节码 session.write("收到"); } }
Netty:
Netty中解码器和MINA类似,解码器继承抽象类ByteToMessageDecoder,实现decode方法:
public class MyNettyDecoder extends ByteToMessageDecoder { @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { // 如果没有接收完Header部分(4字节),直接退出该方法 if(in.readableBytes() >= 4) { // 标记开始位置,如果一条消息没传输完成则返回到这个位置 in.markReaderIndex(); byte[] bytes = new byte[4]; in.readBytes(bytes); // 读取4字节的Header int bodyLength = LittleEndian.getLittleEndianInt(bytes); // header按小字节序转int // 如果body没有接收完整 if(in.readableBytes() < bodyLength) { in.resetReaderIndex(); // ByteBuf回到标记位置 } else { byte[] bodyBytes = new byte[bodyLength]; in.readBytes(bodyBytes); String body = new String(bodyBytes, "UTF-8"); out.add(body); // 解析出一条消息 } } } }
下面是编码器,继承自抽象类MessageToByteEncoder,实现encode方法:
public class MyNettyEncoder extends MessageToByteEncoder<String> { @Override protected void encode(ChannelHandlerContext ctx, String msg, ByteBuf out) throws Exception { byte[] bytes = msg.getBytes("UTF-8"); int length = bytes.length; byte[] header = LittleEndian.toLittleEndian(length); // int按小字节序转字节数组 out.writeBytes(header); // write header out.writeBytes(bytes); // write body } }
加上相应的编码器和解码器:
public class TcpServer { public static void main(String[] args) throws InterruptedException { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); // 加上自己的Encoder和Decoder pipeline.addLast(new MyNettyDecoder()); pipeline.addLast(new MyNettyEncoder()); pipeline.addLast(new TcpServerHandler()); } }); ChannelFuture f = b.bind(8080).sync(); f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } }
业务逻辑处理类:
public class TcpServerHandler extends ChannelInboundHandlerAdapter { // 接收到新的数据 @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { // MyNettyDecoder将接收到的数据由ByteBuf转为String String message = (String) msg; System.out.println("channelRead:" + message); // MyNettyEncoder将write的字符串添加了一个小字节序Header并转为字节码 ctx.writeAndFlush("收到"); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } }
Twisted:
Twisted的实现方式和MINA、Netty不太一样,其实现方式相对来说更加原始,但是越原始也越接近底层原理。
首先要定义一个MyProtocol类继承自Protocol,用于充当类似于MINA、Netty的编码、解码器。处理业务逻辑的类TcpServerHandle继承MyProtocol,重写或调用MyProtocol提供的一些方法。
# -*- coding:utf-8 –*- from struct import pack, unpack from twisted.internet.protocol import Factory from twisted.internet.protocol import Protocol from twisted.internet import reactor # 编码、解码器 class MyProtocol(Protocol): # 用于暂时存放接收到的数据 _buffer = b"" def dataReceived(self, data): # 上次未处理的数据加上本次接收到的数据 self._buffer = self._buffer + data # 一直循环直到新的消息没有接收完整 while True: # 如果header接收完整 if len(self._buffer) >= 4: # 按小字节序转int length, = unpack("<I", self._buffer[0:4]) # 如果body接收完整 if len(self._buffer) >= 4 + length: # body部分 packet = self._buffer[4:4 + length] # 新的一条消息接收并解码完成,调用stringReceived self.stringReceived(packet) # 去掉_buffer中已经处理的消息部分 self._buffer = self._buffer[4 + length:] else: break; else: break; def stringReceived(self, data): raise NotImplementedError def sendString(self, string): self.transport.write(pack("<I", len(string)) + string) # 逻辑代码 class TcpServerHandle(MyProtocol): # 实现MyProtocol提供的stringReceived而不是dataReceived,不然无法解码 def stringReceived(self, data): # data为MyProtocol解码后的数据 print ‘stringReceived:‘ + data # 调用sendString而不是self.transport.write,不然不能进行编码 self.sendString("收到") factory = Factory() factory.protocol = TcpServerHandle reactor.listenTCP(8080, factory) reactor.run()
下面是Java编写的一个客户端测试程序:
public class TcpClient { public static void main(String[] args) throws IOException { Socket socket = null; OutputStream out = null; InputStream in = null; try { socket = new Socket("localhost", 8080); out = socket.getOutputStream(); in = socket.getInputStream(); // 请求服务器 String data = "http://www.mamicode.com/我是客户端"; byte[] outputBytes = data.getBytes("UTF-8"); out.write(LittleEndian.toLittleEndian(outputBytes.length)); // write header out.write(outputBytes); // write body out.flush(); // 获取响应 byte[] inputBytes = new byte[1024]; int length = in.read(inputBytes); if(length >= 4) { int bodyLength = LittleEndian.getLittleEndianInt(inputBytes); if(length >= 4 + bodyLength) { byte[] bodyBytes = Arrays.copyOfRange(inputBytes, 4, 4 + bodyLength); System.out.println("Header:" + bodyLength); System.out.println("Body:" + new String(bodyBytes, "UTf-8")); } } } finally { // 关闭连接 in.close(); out.close(); socket.close(); } } }
用客户端分别测试上面三个TCP服务器:
MINA服务器输出结果:
messageReceived:我是客户端
Netty服务器输出结果:
channelRead:我是客户端
Twisted服务器输出结果:
channelRead:我是客户端
客户端测试三个服务器的输出结果都是:
Header:6
Body:收到
由于一个汉字一般占3个字节,所以两个汉字对应的Header为6。
Mina、Netty、Twisted一起学(四):定制自己的协议