1.自定义协议客户端与服务器收发逻辑
Netty中自带了多种编解码器，在项目中更常用的是自定义协议进行通信，此时需要自行处理
半包问题，通过继承ByteToMessageDecoder可以方便的解决这个问题。
服务器代码：
Server main：
public class SocketServer {
public static void main(String[] args) throws InterruptedException {
EventLoopGroup parentGroup = new NioEventLoopGroup();
EventLoopGroup childGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(parentGroup, childGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new SelfDefineEncodeHandler());
pipeline.addLast(new BusinessServerHandler());
}
});
ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
channelFuture.channel().closeFuture().sync();
}
finally {
parentGroup.shutdownGracefully();
childGroup.shutdownGracefully();
}
}
}
自定义解码器：SelfDefineEncodeHandler
/**
* 定长消息数据格式
*
* | length | msg | 头部length用4字节存储，存储的长度为消息体msg的总长度
*
*
* */
public class SelfDefineEncodeHandler extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf bufferIn, List<Object> out) throws Exception {
if (bufferIn.readableBytes() < 4) {
return;
}
//返回当前buff中readerIndex索引
int beginIndex = bufferIn.readerIndex();
//在当前readerIndex基础上读取4字节并返回，同时增加readIndex
int length = bufferIn.readInt();
/**
* 1.当可读数据小于length，说明包还没有接收完全
* 2.开始可读为beginindex，此时读完readInt后需要重置readerindex
* 3.重置readerindex后继续等待下一个读事件到来
* */
if (bufferIn.readableBytes() < length) {
//重置当前的readerindex为beginindex
bufferIn.readerIndex(beginIndex);
return;
}
//4字节存放length，这里整个消息长度为4+length，跳过当前消息，增大bufferIn的readindex，bufferIn中数组可复用
bufferIn.readerIndex(beginIndex + 4 + length);
//Returns a slice of this buffer's sub-region.
//取出当前的整条消息并存入otherByteBufRef中
ByteBuf otherByteBufRef = bufferIn.slice(beginIndex, 4 + length);
/**
* 1.每一个bytebuf都有一个计数器，每次调用计数器减1，当计数器为0时则不可用。
* 2.当前bytebuf中数据包含多条消息，本条信息会通过out返回被继续封装成一个新的bytebuf返回下一个hander处理
* 3.retain方法是将当前的bytebuf计数器加1
* */
otherByteBufRef.retain();
out.add(otherByteBufRef);
}
}
消息处理handler
public class BusinessServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
/**
* 1.读数据，这里收到的是一个完整的消息数据，在decoder的out传递到当前逻辑
* 2.对消息进一步的解码
* */
ByteBuf buf = (ByteBuf)msg;
int length = buf.readInt();
assert length == (8);
byte[] head = new byte[4];
buf.readBytes(head);
String headString = new String(head);
assert "head".equals(headString);
byte[] body = new byte[4];
buf.readBytes(body);
String bodyString = new String(body);
assert "body".equals(bodyString);
}
}
客户端逻辑：SocketClient
public class SocketClient {
public static void main(String[] args) throws InterruptedException {
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup)
.channel(NioSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.handler(new ChannelInitializer<SocketChannel>(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new SocketClientHandler());
}});
ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
channelFuture.channel().closeFuture().sync();
}
finally {
eventLoopGroup.shutdownGracefully();
}
}
}
客户端消息发送：
public class SocketClientHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
}
/**
* 1.写数据的逻辑，先写入消息的总长度
* 2.分别写入消息体的内容
* 3.以bytebuf的方式发送数据
* */
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
UnpooledByteBufAllocator allocator = new UnpooledByteBufAllocator(false);
ByteBuf buffer = allocator.buffer(20);
buffer.writeInt(8);
buffer.writeBytes("head".getBytes());
buffer.writeBytes("body".getBytes());
ctx.writeAndFlush(buffer);
}
}
2.使用protobuf可以使用netty自带的编解码器：
（1）启动server
public class Server {
// 实例一个连接容器保存连接
public static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
// 再搞个map保存与用户的映射关系
public static ConcurrentMap<Integer, ChannelId> userSocketMap = new ConcurrentHashMap<Integer, ChannelId>();
private int port;
public ChatServer(int port) {
this.port = port;
}
public void run() throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup();// boss线程池
EventLoopGroup workerGroup = new NioEventLoopGroup();// worker线程池
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)// 使用TCP
.childHandler(new ChatServerInitializer())// 初始化配置的处理器
.option(ChannelOption.SO_BACKLOG, 128)// BACKLOG用于构造服务端套接字ServerSocket对象，标识当服务器请求处理线程全满时，用于临时存放已完成三次握手的请求的队列的最大长度。如果未设置或所设置的值小于1，Java将使用默认值50。
.childOption(ChannelOption.SO_KEEPALIVE, true);// 是否启用心跳保活机制。在双方TCP套接字建立连接后（即都进入ESTABLISHED状态）并且在两个小时左右上层没有任何数据传输的情况下，这套机制才会被激活。
System.out.println("[ChatServer 启动了]");
// 绑定端口，开始接收进来的连接
ChannelFuture f = b.bind(port).sync();
// 等待服务器 socket 关闭 。
// 这不会发生，可以优雅地关闭服务器。
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
System.out.println("[ChatServer 关闭了]");
}
}
}
（2）解码器
public class ChatServerInitializer extends ChannelInitializer<SocketChannel> {
Timer timer;
public ChatServerInitializer() {
timer = new HashedWheelTimer();
}
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// ----Protobuf处理器，这里的配置是关键----
pipeline.addLast("frameDecoder", new ProtobufVarint32FrameDecoder());// 用于decode前解决半包和粘包问题（利用包头中的包含数组长度来识别半包粘包）
//配置Protobuf解码处理器，消息接收到了就会自动解码，ProtobufDecoder是netty自带的，Message是自己定义的Protobuf类
pipeline.addLast("protobufDecoder",new ProtobufDecoder(Message.getDefaultInstance()));
// 用于在序列化的字节数组前加上一个简单的包头，只包含序列化的字节长度。
pipeline.addLast("frameEncoder",new ProtobufVarint32LengthFieldPrepender());
//配置Protobuf编码器，发送的消息会先经过编码
pipeline.addLast("protobufEncoder", new ProtobufEncoder());
// ----Protobuf处理器END----
pipeline.addLast("handler", new ChatServerHandler());//自己定义的消息处理器，接收消息会在这个类处理
pipeline.addLast("ackHandler", new AckServerHandler());//处理ACK
pipeline.addLast("timeout", new IdleStateHandler(100, 0, 0,TimeUnit.SECONDS));// //此两项为添加心跳机制,60秒查看一次在线的客户端channel是否空闲
pipeline.addLast(new HeartBeatServerHandler());// 心跳处理handler
}
// pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
// 2 * 1024, Delimiters.lineDelimiter()));
// pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
// pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
}
（3）消息处理handler
public class ChatServerHandler extends SimpleChannelInboundHandler<Message> {
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
Channel incoming = ctx.channel();
System.out.println("[SERVER] - " + incoming.remoteAddress() + " 连接过来
");
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
Channel incoming = ctx.channel();
ChatServer.channels.remove(incoming);
System.out.println("[SERVER] - " + incoming.remoteAddress() + " 离开
");
// A closed Channel is automatically removed from ChannelGroup,
// so there is no need to do "channels.remove(ctx.channel());"
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Message msg)
throws Exception {
//消息会在这个方法接收到，msg就是经过解码器解码后得到的消息，框架自动帮你做好了粘包拆包和解码的工作
//处理消息逻辑
ctx.fireChannelRead(msg);//把消息交给下一个处理器
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception { // (5)
Channel incoming = ctx.channel();
System.out.println("ChatClient:" + incoming.remoteAddress() + "上线");
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception { // (6)
Channel incoming = ctx.channel();
System.out.println("ChatClient:" + incoming.remoteAddress() + "掉线");
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // (7)
Channel incoming = ctx.channel();
// 当出现异常就关闭连接
System.out.println("ChatClient:" + incoming.remoteAddress()
+ "异常,已被服务器关闭");
cause.printStackTrace();
ctx.close();
}
}
（4）心跳handler
public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter {
private int loss_connect_time = 0;
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
throws Exception {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) {
loss_connect_time++;
System.out.println("[60 秒没有接收到客户端" + ctx.channel().id()
+ "的信息了]");
if (loss_connect_time > 2) {
// 超过20秒没有心跳就关闭这个连接
System.out.println("[关闭这个不活跃的channel:" + ctx.channel().id()
+ "]");
ctx.channel().close();
}
}
} else {
super.userEventTriggered(ctx, evt);
}
}
}