netty自定义channel id
netty自定义channel id、netty custom channel id
搞搞netty时发现默认的id很长，无法直接自定义。
于是我网上搜索了search一下，发现没有相关文章，那就自己看看源码手撸一个实现。这难不倒拥有7年代码经验的我，通过本文章你能大概学到如何根据源码定制功能。
通过netty官网说明唯一id：https://netty.io/wiki/new-and-noteworthy-in-4.1.html
全局唯一通道ID
每个频道现在都有一个全局唯一的ID，该ID由以下内容生成：
优选全局唯一的MAC地址（EUI-48或EUI-64），
当前进程ID，
系统#currentTimeMillis（）
系统#nanoTime（）
随机32位整数
顺序递增的32位整数
可以使用信道获得信道的ID.id()方法。
默认的id是这样的：通道id：a85e45fffec07f9b-00002454-00000000-084db96c90765225-d150e0b4
虽然很唯一，但不符合我们的系统，应该将它自定义。
一、自定义ID试调源码过程
我是基于netty 4.1.79.Final 2022年8月12日最新版本。
首先看id的实现接口：IDEA中按Ctrl + Alt + O 搜索 channel ID
应该就是这个了ChannelId接口了，接着看他的实现类
应该就是默认的实现了
观察到id为空时他就会new一个
接着看一下哪里用他生成：
此时我们发现是一个构造类用到了他AbstractChannel，AbstractChannel应该就是所有管道类的父类。
他的构造方法中也newId()了
他就是在这里吧ID给生成出来：
框架开发一般规则/套路：不直接使用构造类，那么我们看看他的继承使用情况：
太多了，我们不知道哪个会加载。
回到我们的客户端初始化类，看看能不能在初始化配置时找到自定义他的地方：
此时发现打印的是class io.netty.channel.socket.nio.NioSocketChannel这个类，恰好对应上面的NioSocketChannel处理
NioSocketChannel这个是客户端的管道处理类，默认是使用socket协议。恰好发现它是继承了AbstractChannel，
二、走查源码自定义结果
那应该就是通过自定义NioSocketChannel这个类进行自定义id生成。
三、实现自定义
通过上面的结果，我们通过继承NioSocketChannel来实现自定义id生成：使用UUID
import io.netty.channel.ChannelId;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.util.UUID;
/**
* @author lingkang
* Created by 2022/8/12
*/
public class MyNioSocketChannel extends NioSocketChannel {
protected ChannelId newId() {
ChannelId channelId = new ChannelId() {
@Override
public String asShortText() {
return UUID.randomUUID().toString();
}
@Override
public String asLongText() {
return UUID.randomUUID().toString();
}
@Override
public int compareTo(ChannelId o) {
return 0;
}
};
return channelId;
}
}
客户端初始化那就是用我们集成自定义的类
运行结果：
这个自定义是正确的，所以服务端也能按照上面的思路进行自定义。
四、完整代码：
import io.netty.channel.ChannelId;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.util.UUID;
/**
* @author lingkang
* Created by 2022/8/12
*/
public class MyNioSocketChannel extends NioSocketChannel {
protected ChannelId newId() {
ChannelId channelId = new ChannelId() {
@Override
public String asShortText() {
return UUID.randomUUID().toString();
}
@Override
public String asLongText() {
return UUID.randomUUID().toString();
}
@Override
public int compareTo(ChannelId o) {
return 0;
}
};
return channelId;
}
}
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import top.lingkang.flychat.common.MsgBody;
import top.lingkang.flychat.common.code.RpcDecoder;
import top.lingkang.flychat.common.code.RpcEncoder;
import top.lingkang.flychat.server.ServerHandler;
import top.lingkang.flychat.server.ServerInit;
import java.util.Date;
/**
* @author lingkang
* Created by 2022/8/12
*/
public class Test01Server {
public static void main(String[] args) {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workGroup)
.channel(NioServerSocketChannel.class)
// 当服务器请求处理线程全满时，用于临时存放已完成三次握手的请求的队列的最大长度。
.option(ChannelOption.SO_BACKLOG, 50)
// .childOption(ChannelOption.SO_KEEPALIVE, true)
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
.childHandler(new ChannelInitializer<SocketChannel>(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline()
.addFirst("encode", new RpcEncoder(MsgBody.class))//编码器
.addFirst("decode", new RpcDecoder(MsgBody.class))//解码器
.addLast(new ChannelInboundHandlerAdapter(){
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
MsgBody body = (MsgBody) msg;
System.out.println("接收到Client端信息:" + body.toString());
//返回的数据结构
MsgBody response = new MsgBody();
response.setCode(200);
response.setData(new Date());
response.setMsg("server响应结果");
System.out.println("server thread id=" + Thread.currentThread().getId());
ctx.writeAndFlush(response);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
closeOnFlush(ctx.channel());
}
private void closeOnFlush(Channel ch) {
if (ch.isActive()) {
ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
super.handlerRemoved(ctx);
System.out.println("有链接断开");
}
});
}
});
//启动同步监听
serverBootstrap.bind("127.0.0.1", 8081).sync().channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
workGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import top.lingkang.flychat.common.MsgBody;
import top.lingkang.flychat.common.code.RpcDecoder;
import top.lingkang.flychat.common.code.RpcEncoder;
import java.util.Date;
/**
* @author lingkang
* Created by 2022/8/12
*/
public class Test01Client {
public static void main(String[] args) throws Exception {
Bootstrap bootstrap = new Bootstrap();
EventLoopGroup group = new NioEventLoopGroup(1);
try {
bootstrap
.group(group)
.channel(MyNioSocketChannel.class)// 使用NioSocketChannel来作为连接用的channel类
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
System.out.println(ch.getClass());
ch.pipeline()
.addFirst("encode", new RpcEncoder(MsgBody.class))//编码器
.addFirst("decode", new RpcDecoder(MsgBody.class))//解码器
.addLast(new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
MsgBody body = (MsgBody) msg;
System.out.println("接收到Server端响应消息：" + body.toString());
// throw new RuntimeException("手动抛出");
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
closeOnFlush(ctx.channel());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
closeOnFlush(ctx.channel());
}
private void closeOnFlush(Channel ch) {
if (ch.isActive()) {
ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
}
});
}
});
// Start the connection attempt.
Channel channel = bootstrap.connect("127.0.0.1", 8081).sync().channel();
System.out.println("连接服务器成功");
int i = 0;
while (true) {
try {
//每2秒给服务器发一次数据
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
channel.writeAndFlush(new MsgBody(200, "客户端给服务端发消息：" + i, new Date()));
if (i == 5) {
System.out.println("通道id：" + channel.id().asLongText());
channel.close();
break;
}
}
} finally {
//关闭线程组
group.shutdownGracefully();
}
}
}
