编码解码
回顾Netty的几个组件
-
Channel
服务器和客户端建立的连接通道
-
ChannelPipeline
管道，一个通道包含一个管道，管道包含一个处理器链
-
ChannelHandler
管道中的处理器链包含多个处理器，每个处理器可以处理不同的IO事件，是双向链表结构，包含head头部和tail尾部。
处理器分为：
-
ChannelInboundHandler
入站消息处理器（处理进入的消息）
-
ChannelOutboundHandler
出站消息处理器（处理出去的消息）
-
编码和解码
Netty在接收和发送消息时都需要进行数据转换。
接收消息时（入站）需要把字节转换为自己的格式（字符串、对象等），这就是解码。
发送消息时把自己的格式转换为字节，这就是编码。
编码器继承MessageToMessageEncoder类 ，实现了ChannelOutboundHandler 接口
解码器继承MessageToMessageDecoder类，实现了ChannelInboundHandler接口
Netty自带的编码解码器有：
- StringEncoder字符串编码器
- StringDecoder字符串解码器
- ObjectEncoder对象编码器
- ObjectDecoder对象解码器
- …
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 1024)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//向pipeline加入字符串解码器
pipeline.addLast("decoder", new StringDecoder());
//向pipeline加入字符串编码器
pipeline.addLast("encoder", new StringEncoder());
//加入自己的业务处理handler
pipeline.addLast(new ChatServerHandler());
}
});
以聊天室程序为例，先在管道中加入了字符串解码器，这样就能将字节转换为字符串，读取打印出来；然后加入了字符串编码器，这些在发送数据时，将字符串转换为字节发送出去。
自定义编码和解码器
开发者可以自定义编码解码器
自定义解码器
/**
* byte转long解码器
*/
public class ByteToLongDecoder extends ByteToMessageDecoder {
/**
* 重写编码方法
* @param ctx
* @param in
* @param out
* @throws Exception
*/
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
System.out.println("解码方法被调用");
//读取长整型需要的8个字节
if(in.readableBytes() >= 8) {
out.add(in.readLong());
}
}
}
自定义解码器
/**
* long转byte编码器
*/
public class LongToByteEncoder extends MessageToByteEncoder<Long> {
/**
* 重写编码方法
* @param ctx
* @param in
* @param out
* @throws Exception
*/
@Override
protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
System.out.println("编码方法被调用 " + msg);
out.writeLong(msg);
}
}
服务器和客户端在添加处理器时，可以加入编码器和解码器
public class NettyServer {
public static void main(String[] args) throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//给服务器添加了long类型的解码器和编码器
pipeline.addLast(new ByteToLongDecoder());
pipeline.addLast(new LongToByteEncoder());
pipeline.addLast(new NettyServerHandler());
}
});
System.out.println("netty server start。。");
ChannelFuture channelFuture = serverBootstrap.bind(9000).sync();
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
服务器和客户端的业务处理器中，就可以读取和发送long的数据
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("从客户端读取到Long：" + (Long)msg);
//给客户端发回一个long数据
ctx.writeAndFlush(2000L);
}
}
public class NettyLongClient {
public static void main(String[] args) {
//创建处理IO的线程组
EventLoopGroup workerGroup = new NioEventLoopGroup();
//创建启动对象
Bootstrap bootstrap = new Bootstrap();
try {
//设置线程组
bootstrap.group(workerGroup)
//设置通道类型
.channel(NioSocketChannel.class)
//设置初始化器
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
ChannelPipeline pipeline = socketChannel.pipeline();
//配置编码和解码器
pipeline.addLast(new ByteToLongDecoder());
pipeline.addLast(new LongToByteEncoder());
}
});
//连接服务器
ChannelFuture cf = bootstrap.connect("127.0.0.1",9000).sync();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
long msg = scanner.nextLong();
//发送消息
cf.channel().writeAndFlush(msg);
}
}catch (Exception ex){
ex.printStackTrace();
}finally {
//关闭线程组
workerGroup.shutdownGracefully();
}
}
}
粘包拆包
Netty是基于TCP协议的，TCP是面向流的，数据没有边界，操作系统在发送时会通过缓冲区进行优化，缓冲区有固定大小，如1024字节。
粘包
如果一次发送数据时，数据量没有达到缓冲区大小，TCP会将多个数据包合到一起发送，这样就形成了粘包
拆包
如果一次发送数据时，数据量超过了缓冲区大小，TCP会将数据拆分成多个数据包发送，这样就是拆包
如下图所示，出现几种情况
- 理想情况，两次发送的数据包正好是缓冲区大小，就正常作为两个数据包发送
- 出现粘包，两次发送的数据包加一起等于缓冲区大小，将两个包合并为一个包发送
- 出现拆包，一次发送的包超过了缓冲区，分成了多个包发送
- 拆包/粘包同时发生，一个包比缓冲区大，一个比缓冲区小，会将大的包拆开和小的包合并到一起发送
数据一般有完整性，如：文件、字符串等，发生粘包和拆包会导致数据出现混乱。
解决方案：
- 规定固定长度，如100字节，按长度拆分
- 设置某些字符作为分隔符，如：\r\n，读取后按分隔符进行数据拆分
- 数据包中包含长度，读取到后对数据进行拆分
- 使用特定的协议，消息头中包含长度，进行粘包和拆包处理
Netty提供了一些解码器(Decoder)来解决粘包和拆包的问题。如：
- LineBasedFrameDecoder 以行(\r\n)为单位进行数据包的解码;
- DelimiterBasedFrameDecoder：以特殊的符号作为分隔来进行数据包的解码;
- FixedLengthFrameDecoder：以固定长度进行数据包的解码;
- LengthFieldBasedFrameDecoder：适用于消息头包含消息长度的协议;
零拷贝
Java的内存按分配位置分为：
- 堆内内存（JVM堆中分配的内存）
- 直接内存（JVM外部分配的内存）
Socket网络通信时，数据通过网络发送到网卡，先通过网卡保存到直接内存中，再从直接内存中把数据复制到JVM堆中，才能对数据进行操作。
Netty采用的是零拷贝机制，在JVM中直接引用直接内存中的数据，不需要进行拷贝，提高了IO效率。
ByteBuffer类的allocate方法用于分配堆内内存，allocateDirect方法用于分配直接内存
/**
* 直接内存与堆内存的区别
*/
public class DirectMemoryTest {
/**
* 访问堆内存
*/
public static void heapAccess() {
long startTime = System.currentTimeMillis();
//分配堆内存
ByteBuffer buffer = ByteBuffer.allocate(1000);
for (int i = 0; i < 100000; i++) {
for (int j = 0; j < 200; j++) {
buffer.putInt(j);
}
buffer.flip();
for (int j = 0; j < 200; j++) {
buffer.getInt();
}
buffer.clear();
}
long endTime = System.currentTimeMillis();
System.out.println("堆内存访问:" + (endTime - startTime));
}
/**
* 访问直接内存
*/
public static void directAccess() {
long startTime = System.currentTimeMillis();
//分配直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(1000);
for (int i = 0; i < 100000; i++) {
for (int j = 0; j < 200; j++) {
buffer.putInt(j);
}
buffer.flip();
for (int j = 0; j < 200; j++) {
buffer.getInt();
}
buffer.clear();
}
long endTime = System.currentTimeMillis();
System.out.println("直接内存访问:" + (endTime - startTime));
}
/**
* 分配堆内存
*/
public static void heapAllocate() {
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
ByteBuffer.allocate(100);
}
long endTime = System.currentTimeMillis();
System.out.println("堆内存申请:" + (endTime - startTime));
}
/**
* 分配直接内存
*/
public static void directAllocate() {
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
ByteBuffer.allocateDirect(100);
}
long endTime = System.currentTimeMillis();
System.out.println("直接内存申请:" + (endTime - startTime));
}
public static void main(String args[]) {
for (int i = 0; i < 5; i++) {
heapAccess();
directAccess();
}
System.out.println("============================");
for (int i = 0; i < 5; i++) {
heapAllocate();
directAllocate();
}
}
}
通过运行结果可以看到：堆内存的访问效率低于直接内存，堆内存的分配速度高于直接内存
使用直接内存的优缺点：
优点：
-
不占用堆内存空间，减少了发生GC的可能
-
Java虚拟机实现上，本地IO会直接操作直接内存（直接内存=>系统调用=>硬盘/网卡），而非直接内存则需要二次拷贝（堆内存=>直接内存=>系统调用=>硬盘/网卡）
缺点：
- 初始分配较慢
- 没有JVM直接帮助管理内存，容易发生内存溢出。为了避免一直没有FULL GC，最终导致直接内存把物理内存被耗完。我们可以指定直接内存的最大值，通过-XX：MaxDirectMemorySize来指定，当达到阈值的时候，调用system.gc来进行一次FULL GC，间接把那些没有被使用的直接内存回收掉。
心跳检测
TCP在长连接时，会定期在客户端和服务器之间发送心跳包（一种很小的数据包），通知对方自己在线，一旦长期收不到心跳包，则认为对方离线，自己可以进行异常处理。
Netty的IdleStateHandler可以实现心跳检测机制
构造方法
IdleStateHandler(int readerIdleTime, int writerIdleTime, int allIdleTime,TimeUnit unit )
参数：
- readerIdleTime：读超时. 即当在指定的时间间隔内没有从 Channel 读取到数据时会触发
- writerIdleTime：写超时. 即当在指定的时间间隔内没有数据写入到 Channel 时会触发
- allIdleTime：读/写超时. 即当在指定的时间间隔内没有读或写操作时会触发
- unit：时间单位
带心跳检测机制的服务器端
添加了IdleStateHandler，并设置读超时为3秒，3秒没有读取客户端消息则会触发下一个处理器中的userEventTriggered方法
public class HeartBeatServer {
public static void main(String[] args) throws Exception {
EventLoopGroup boss = new NioEventLoopGroup();
EventLoopGroup worker = new NioEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(boss, worker)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
//IdleStateHandler的readerIdleTime参数指定超过3秒还没收到客户端的连接，
//会触发IdleStateEvent事件并且交给下一个handler处理，下一个handler必须
//实现userEventTriggered方法处理对应事件
pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
pipeline.addLast(new HeartBeatServerHandler());
}
});
System.out.println("netty server start。。");
ChannelFuture future = bootstrap.bind(9000).sync();
future.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
worker.shutdownGracefully();
boss.shutdownGracefully();
}
}
}
服务器处理器
重写了userEventTriggered方法，执行心跳超时的处理逻辑
public class HeartBeatServerHandler extends SimpleChannelInboundHandler<String> {
private int readIdleTimes = 0;
@Override
protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
System.out.println(" ====== > [server] message received : " + s);
if ("Heartbeat Packet".equals(s)) {
ctx.channel().writeAndFlush("ok");
} else {
System.out.println(s);
}
}
//触发超时事件
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
IdleStateEvent event = (IdleStateEvent) evt;
String eventType = null;
switch (event.state()) {
case READER_IDLE:
eventType = "读空闲";
readIdleTimes++; // 读空闲的计数加1
break;
case WRITER_IDLE:
eventType = "写空闲";
// 不处理
break;
case ALL_IDLE:
eventType = "读写空闲";
// 不处理
break;
}
System.out.println(ctx.channel().remoteAddress() + "超时事件：" + eventType);
if (readIdleTimes > 3) {
System.out.println(" [server]读空闲超过3次，关闭连接，释放更多资源");
ctx.channel().writeAndFlush("idle close");
ctx.channel().close();
}
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.err.println("=== " + ctx.channel().remoteAddress() + " is active ===");
}
}
客户端定期发送心跳数据包
public class HeartBeatClient {
public static void main(String[] args) throws Exception {
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast(new HeartBeatClientHandler());
}
});
System.out.println("netty client start。。");
Channel channel = bootstrap.connect("127.0.0.1", 9000).sync().channel();
String text = "Heartbeat Packet";
Random random = new Random();
//随机时间间隔发送心跳包
while (channel.isActive()) {
int num = random.nextInt(10);
Thread.sleep(num * 1000);
channel.writeAndFlush(text);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
eventLoopGroup.shutdownGracefully();
}
}
static class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
System.out.println(" client received :" + msg);
if (msg != null && msg.equals("idle close")) {
System.out.println(" 服务端关闭连接，客户端也关闭");
ctx.channel().closeFuture();
}
}
}
}
扫一扫
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
