Netty多语言（Java、Android 、C#、WebSocket）通信实例Demo （二）Java端简介【附源码】

转载请注明出处,原文地址:https://blog.csdn.net/lucherr/article/details/88378235

Netty多语言（Java、Android 、C#、WebSocket）通信实例Demo （一）概述 【附源码】
Netty多语言（Java、Android 、C#、WebSocket）通信实例Demo （二）Java端简介【附源码】
Netty多语言（Java、Android 、C#、WebSocket）通信实例Demo （三）Android端简介【附源码】
Netty多语言（Java、Android 、C#、WebSocket）通信实例Demo （四）C#端简介【附源码】
 

该项目源码中，包含了Java服务端、Java客户端、WebSocket示例源码，对应的源码目录为NettyServer：

 源码结构如下图：

 服务端：

        Netty的强大之处在于他的API使用非常简单、功能强大、扩展性很强，对于简单的一个Demo来说，几句代码就可以搞定，在本Demo中，由于同时支持了TCP和WebSocket协议，而且使用了自定义的编解码器，TCP使用MessagePack，WebSocket使用了Json，传递的事件对象也是加入了类的继承关系以及枚举，所以增加了Demo的复杂度，所以这个Demo并不是单纯的想要展示这几个端是怎么通信的，而是更加符合实际开发而加入了一些相对复杂的设定。

        使用Netty开发我们主要关心的就是编解码类、消息处理类的实现，对于编解码Netty提供了一些简单的编解码器，也可以很方便的定制自己的编解码器，对于TCP粘包和拆包问题解决也是So easy，简单的说明一下我对编解码的理解，首先说说概念：编码可以理解为序列化：是指将对象转换为字节数组的过程。 
解码可以理解为反序列化：是指将字节数组还原成原始对象的过程。
为什么需要编码？需要将变量或对象从内存中取出来进行存储或传输。

        我觉得可以将Netty中的编解码用大家都熟悉的快递业务来对比说明，这样比较好理解，因为本例中使用了2种协议，所以举例的时候会将协议一起说明。

收发快递例子说明Netty编解码：
Netty就像是快递柜，你可以通过它收发快递，它支持N家快递公司，它的服务很专业
协议就像是这里的快递公司，用不同的快递公司将会用不同的包装将你的包裹包装起来
编码就像是要邮寄物品的时候，把物品打包成包裹的过程
解码就像是领取包裹后，拆开包裹的过程
        来一个案例：现在你是一个小服装厂的老板（刚开始干），有个客户在网上购买了一件衣服需要试穿，你高兴的不得了，现在你要把衣服邮寄给她，你家楼下有个快递柜（也就是Netty，特别省事特别方便），客户那边说了只方便收顺丰的快递（也就是指定了协议，ps：顺丰没有给我广告费），于是你在邮寄的时候选择了顺丰，当然衣服你不能直接就塞快递柜里了，你还得给它细心的包装起来，你可以随便找个袋或者纸壳箱子把衣服塞进去用透明胶带给粘上，也可能你有专业人士给你设计的高大上包装盒，里面还放了一张五星好评返红包的卡片，再加个小礼物（把衣服用包装盒抱起来，里面加入小卡片和小礼物的这个过程就是编码本码没错了，好比Demo中的MessagePack打包方式），用包装盒打包完成包裹后，放进快递柜，顺丰的工作人员拿出包裹后，贴上了顺丰的快递单（相当于Demo中的TCP协议），然后把这个快递发出去了（你的数据包发出去了），第二天，客户收到快递包裹了，上面贴着顺丰的快递单，然后她开始拆包裹（也就是解码过程了，之前你怎么给它包起来的，她就怎么拆开，Demo中就是收到消息也得用MessagePack解包），然后取出了衣服，她看到这个包装盒真的很漂亮还看到了小礼物，觉得你太贴心了，感动的眼泪都差点出来了，于是赶紧把衣服拿回家试穿（这里就相当于是Handler做的事了），试完后发现稍微有点小，然后她决定换一件大点的，然后又把衣服打包发给你，依然选了TCP协议，进行编码，再发给你，你又解码，看看衣服有没有损坏......编不下去了哈哈，表达能力有待提升，就这个小例子都编了半天，相信你的理解能力。

        下面来看看编码类，使用了MessagePack进行打包，也就是你把衣服装到包装盒里的过程，你得把你要发的消息打包起来，这样才能给快递公司寄出去，MessagePack的API可以查看官网：https://msgpack.org/

public class MessagePackEncoder extends MessageToByteEncoder<Object> {

	@Override
	protected void encode(ChannelHandlerContext ctx, Object obj, ByteBuf buf) throws Exception {
		MessagePack msgPack = new MessagePack();
		//序列化操作
		byte[] bytes = msgPack.write(obj);
		//netty操作,将对象序列化数组传入ByteBuf
		buf.writeBytes(bytes);
	}
}

         解码类，与编码对应，也使用MessagePack进行解包，就是收到包裹后，拆开包裹取出衣服的过程

public class MessagePackDecoder extends MessageToMessageDecoder<ByteBuf> {
	
	@Override
	protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> objs) throws Exception {
		final byte[] bytes;
		final int length = buf.readableBytes();
		bytes = new byte[length];
		// 从数据包buf中获取要操作的byte数组
		buf.getBytes(buf.readerIndex(), bytes, 0, length);
		// 将bytes反序列化成对象,并添加到解码列表中
		MessagePack msgpack = new MessagePack();
		
		objs.add(msgpack.read(bytes));

	}
}

         Demo中比较麻烦的一个问题是同时支持TCP和WebSocket协议，做之前也调研过，最简单的办法就是监听2个端口，分别做不同的编解码，但是我还是想要在一个端口同时实现TCP和WebSocket协议的支持，后来也是借鉴了有个网友的方法，根据协议动态修改编解码器，判断的方法是获取协议签名的几个字符进行判断，如果是WebSocket的协议会有一个固定的协议信息，根据这个信息来判断是WebSocket还是TCP，由于目前就支持这两种协议，所以可以按照目前ProtocolDecoder中的判断方式，具体办法就是先将TCP和WebSocket使用的编解码器都加入，然后在ProtocolDecoder中进行判断，具体实现逻辑请查看Demo中的代码

public class NettyServer extends Thread {
......
@Override
protected void initChannel(Channel ch) throws Exception {
	ChannelPipeline pipeline = ch.pipeline();
	// 协议解码处理器，判断是什么协议（WebSocket还是TcpSocket）,然后动态修改编解码器
	pipeline.addLast("protocolHandler", new ProtocolDecoder());

	/** TcpSocket协议需要使用的编解码器 */
	// Tcp粘包处理，添加一个LengthFieldBasedFrameDecoder解码器，它会在解码时按照消息头的长度来进行解码。
	pipeline.addLast("tcpFrameDecoder", new LengthFieldBasedFrameDecoder(65535, 0, 4, 0, 4));
	// MessagePack解码器，消息进来后先由frameDecoder处理，再给msgPackDecoder处理
	pipeline.addLast("tcpMsgPackDecoder", new MessagePackDecoder());
	// Tcp粘包处理，添加一个
	// LengthFieldPrepender编码器，它会在ByteBuf之前增加4个字节的字段，用于记录消息长度。
	pipeline.addLast("tcpFrameEncoder", new LengthFieldPrepender(4));
	// MessagePack编码器，消息发出之前先由frameEncoder处理，再给msgPackEncoder处理
	pipeline.addLast("tcpMsgPackEncoder", new MessagePackEncoder());

	/** WebSocket协议需要使用的编解码器 */
	// websocket协议本身是基于http协议的，所以这边也要使用http解编码器
	pipeline.addLast("httpCodec", new HttpServerCodec());
	// netty是基于分段请求的，HttpObjectAggregator的作用是将请求分段再聚合,参数是聚合字节的最大长度
	pipeline.addLast("httpAggregator", new HttpObjectAggregator(65536));
	// 用于向客户端发送Html5文件，主要用于支持浏览器和服务端进行WebSocket通信
	pipeline.addLast("httpChunked", new ChunkedWriteHandler());

	// 管道消息处理
	pipeline.addLast("channelHandler", new ServerChannelHandler());
}
......

public class ProtocolDecoder extends ByteToMessageDecoder {

	/**
	 * 请求行信息的长度，ws为：GET /ws HTTP/1.1， Http为：GET / HTTP/1.1
	 */
	private static final int PROTOCOL_LENGTH = 16;
	/**
	 * WebSocket握手协议的前缀， 本例限定为：GET /ws ，在访问ws的时候，请求地址需要为如下格式 ws://ip:port/ws
	 */
	private static final String WEBSOCKET_PREFIX = "GET /ws";

	@Override
	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
		String protocol = getBufStart(in);
//		System.out.println("ProtocolHandler protocol:" + protocol);
		if (protocol.startsWith(WEBSOCKET_PREFIX)) {// WebSocket协议处理,移除TcpSocket相关编解码器
			ctx.pipeline().remove("tcpFrameDecoder");
			ctx.pipeline().remove("tcpMsgPackDecoder");
			ctx.pipeline().remove("tcpFrameEncoder");
			ctx.pipeline().remove("tcpMsgPackEncoder");
			// 将对应的管道标记为ws协议
			ChannelWraper channelWraper = NettyServer.CLIENTS.get(ctx.channel().id().asLongText());
			if (channelWraper != null) {
				channelWraper.setProtocol(ChannelWraper.PROTOCOL_WS);
			}
		} else {// TcpSocket协议处理,移除WebSocket相关编解码器
			ctx.pipeline().remove("httpCodec");
			ctx.pipeline().remove("httpAggregator");
			ctx.pipeline().remove("httpChunked");
			// 将对应的管道标记为tcp协议
			ChannelWraper channelWraper = NettyServer.CLIENTS.get(ctx.channel().id().asLongText());
			if (channelWraper != null) {
				channelWraper.setProtocol(ChannelWraper.PROTOCOL_TCP);
			}
		}
		// 重置index标记位
		in.resetReaderIndex();
		// 移除该协议处理器，该channel后续的处理由对应协议安排好的编解码器处理
		ctx.pipeline().remove(this.getClass());
	}

	/**
	 * 获取buffer中指定长度的信息
	 * 
	 * @param in
	 * @return
	 */
	private String getBufStart(ByteBuf in) {
		int length = in.readableBytes();
		if (length > PROTOCOL_LENGTH) {
			length = PROTOCOL_LENGTH;
		}
		// 标记读取位置
		in.markReaderIndex();
		byte[] content = new byte[length];
		in.readBytes(content);
		return new String(content);
	}
}

         还值得一提的就是Handler的处理，由于支持2中协议，TCP协议采用了MessagePack编解码，WebSocket使用JSON，所以对接受到的消息做了object类型的判断，根据不同类型使用不同的方法处理：

public class ServerChannelHandler extends SimpleChannelInboundHandler<Object> {
......
// 接收到消息
@Override
protected void channelRead0(ChannelHandlerContext ctx, final Object object) throws Exception {
	// 管道读取到消息，先判断消息对象是什么类型，然后做不同处理
	try {
		if (object instanceof ArrayValue) {// 这是经过MessagePack解码完成后的对象
			handleValue(ctx, (ArrayValue) object);
		} else if (object instanceof FullHttpRequest) {// HTTP请求对象
			handleHttpRequest(ctx, (FullHttpRequest) object);
		} else if (object instanceof WebSocketFrame) {// WebSocket消息对象
			handleWebSocketFrame(ctx, (WebSocketFrame) object);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}
......

        这里具体就不讲那么细了，要不然篇幅会很长，代码里有详细注释，大家稍微看看就明白。经过上面的处理，最后封装了一个方法来处理不同协议的处理逻辑，这个方法的目的就是通过2种协议传来的数据还原成对象后，交给统一的方法处理逻辑

public class ServerChannelHandler extends SimpleChannelInboundHandler<Object> {
......
/**
 * 统一处理Event，为了让TCP和Websocket的处理逻辑统一，封装了该方法,两种协议的对象采用不同序列化方案
 * 
 * @param eventType
 * @param value
 * @param text
 * @throws IOException
 */
private void handleEvent(EventType eventType, Value value, String text) throws IOException {
	switch (eventType) {// 对于测试类事件，转发给所有终端
	case TEST_EVENT:
		TestEvent testEvent = null;
		if (value != null) {// 如果是tcp协议，采用messagepack序列化
			testEvent = MessageConverter.converter(value, TestEvent.class);
		} else {// ws使用json序列化
			testEvent = JSON.parseObject(text, TestEvent.class);
		}
		System.out.println("收到新消息:" + testEvent);
		// 将该消息转发给所有终端
		sendEventToAll(testEvent);

		break;
	case OTHER_EVENT:// 其他事件，暂未处理
		System.out.println("未处理，主要用于测试判断不同类型事件");
		break;

	default:
		break;
	}
}
......

客户端：

        讲完服务端后，感觉客户端已经没什么好说的，需要注意的就是使用的编解码器与服务器端对应，就是你发的那个衣服的快递，怎么包装的，买家那边也会怎么拆开包装，你包了两层，她就需要拆两层

public class NettyClient extends Thread {
......
@Override
protected void initChannel(SocketChannel ch) throws Exception {
	ChannelPipeline pipeline = ch.pipeline();
	// Tcp粘包处理，添加一个LengthFieldBasedFrameDecoder解码器，它会在解码时按照消息头的长度来进行解码。
	pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(65535, 0, 4, 0, 4));
	// MessagePack解码器，消息进来后先由frameDecoder处理，再给msgPackDecoder处理
	pipeline.addLast("msgPackDecoder", new MessagePackDecoder());
	// Tcp粘包处理，添加一个
	// LengthFieldPrepender编码器，它会在ByteBuf之前增加4个字节的字段，用于记录消息长度。
	pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));
	// MessagePack编码器，消息发出之前先由frameEncoder处理，再给msgPackEncoder处理
	pipeline.addLast("msgPackEncoder", new MessagePackEncoder());
	// 消息处理handler
	pipeline.addLast("handler", new NettyClientHandler());
}
......

         当然，你的IP和端口号需要与服务端对应：

public class RunClient {

	// Server端IP地址，根据实际情况进行修改
	static final String HOST = System.getProperty("host", "127.0.0.1");
	// Netty服务端监听端口号
	static final int PORT = Integer.parseInt(System.getProperty("port", "8888"));
......

WebSocket端：

        代码没什么难度，就一个html文件，直接用支持WebSocket的浏览器打开即可，里面也加入了注释，直接在之前基于WebSocket实现的Android和H5聊天通讯实例【附效果图附所有源码】这篇文章Demo的基础上修改的，代码就不粘这里占空间了，需要注意的仍然是IP和端口号要与服务端对应：

//参数就是与服务器连接的地址
socket = new WebSocket("ws://127.0.0.1:8888/ws");

//客户端收到服务器消息的时候就会执行这个回调方法
socket.onmessage = function(event) {
	console.log("onmessage:"+event.data);
	var ta = document.getElementById("responseText");
	//解析json
	var testEvent = JSON.parse(event.data);
	//将内容加入到文本框中
	ta.value = "【" +testEvent.time +","+testEvent.content +"】\n"+ta.value;
}

源码地址：

CSDN下载 积分不受我的控制

Github地址

PS：如果发现代码中有写的不对、有更好的实现方法或者文章中有误的地方，还望各位指出，我及时修改