netty是一个非常棒的NIO框架就不介绍了。protobuf是google提供的一个开源序列化框架,也是一个非常棒的东西。这里不介绍这两个框架了,想要了解的朋友网上一搜一大把。
本文主要介绍 protobuf3与netty4 在tcp协议里的整合使用。个人认为netty与protobuf是绝配的组合。配合使用非常棒,框架提供了粘包拆包等工具类。特别是你要实现如及时通讯功能的时候,能让你省很多功夫。
使用protobuf需要事先预编译,这个过程这里就不介绍了,我的博客里面有,需要的可以看看。
首先在java中使用netty与protobuf需要两个jar包,我这里是:netty-all-4.1.0.CR7.jar、protobuf-java-3.1.0.jar(可以到maven下载,版本可以不同)
直接来看看代码吧。都有详细的注释:
package com.im.socket.netty.tcp;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.util.concurrent.ConcurrentMap;
import org.jboss.netty.util.internal.ConcurrentHashMap;
/**
* 建立TCP netty服务
*
* @author kokJuis
* @version 1.0
* @date 2016-9-30
*/
public class ChatServer {
// 实例一个连接容器保存连接
public static ChannelGroup channels = new DefaultChannelGroup(
GlobalEventExecutor.INSTANCE);
// 再搞个map保存与用户的映射关系
public static ConcurrentMap userSocketMap = new ConcurrentHashMap();
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 关闭了]");
}
}
}
package com.im.socket.netty.tcp;
import java.util.concurrent.TimeUnit;
import com.im.socket.protobuf.MessageOuterClass.Message;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.protobuf.ProtobufDecoder;
import io.netty.handler.codec.protobuf.ProtobufEncoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import io.netty.util.CharsetUtil;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timer;
/**
* netty处理器配置
*
* @author kokJuis
* @version 1.0
* @date 2016-9-30
*/
public class ChatServerInitializer extends ChannelInitializer {
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));
}
package com.im.socket.netty.tcp;
import java.util.Map.Entry;
import com.im.socket.enums.EnumMessageType;
import com.im.socket.protobuf.MessageOuterClass.Message;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelId;
import io.netty.channel.SimpleChannelInboundHandler;
/**
* 消息处理类
*
* @author kokJuis
* @version 1.0
* @date 2016-9-30
*/
public class ChatServerHandler extends SimpleChannelInboundHandler {
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
Channel incoming = ctx.channel();
System.out.println("[SERVER] - " + incoming.remoteAddress() + " 连接过来\n");
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
Channel incoming = ctx.channel();
ChatServer.channels.remove(incoming);
System.out.println("[SERVER] - " + incoming.remoteAddress() + " 离开\n");
// 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();
}
}
package com.im.socket.netty.tcp;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
/**
* 心跳检测
*
* @ClassName HeartBeatServerHandler
* @Description TODO
* @author kokjuis [email protected]
* @date 2016-9-26
* @content
*/
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);
}
}
}