Netty模型
简易的工作原理示意图：
说明:
- BossGroup线程维护Selector,只关注Accept
- 当接收到Accept事件，获取到对应的SocketChannel，封装成NIOSocketChannel并注册到Worker线程(事件循环)，并进行维护
- 当Worker线程监听到selector中通道发生自己感兴趣的事件后，就由handler进行处理。
详细的工作原理图
说明：
- Netty抽象出两组线程池。BossGroup专门负责接收客户端的链接，workerGroup专门负责网络读写
- BossGroup和WorkerGroup类型都是NioEventLoopGroup
- NioEventLoopGroup相当于一个事件循环组，这个组中还有多个事件循环，每一个事件循环是一个NioEventLoop
- NioEventLoop表示一个不断循环的执行处理任务的线程，每个NioEventLoop都有一个selector，用于监听绑定在其上的socket的网络通讯
- NioEventLoopGroup可以有多个线程，即可有含有多个NioEventLoop
- 每个Boss NioEventLoopGroup循环执行的步骤有三步
- 轮询accept事件
- 处理accept事件，与client建立连接，生成NioSocketChannel，并将其注册到某个worker NioEventLoop上的selector
- 处理任务队列中的任务，即runAllTasks
- 每个Worker NioEventLoop循环执行的在步骤
- 轮询read、write事件
- 处理IO事件，即read/write事件，在对应NioSocketChannel上处理
- 处理任务多列的任务，即runAllTasks
- 每个Worker NioEventLoop 在处理业务时，会使用pipeline(管道)，pipeline中包含了channel，即通过pipeline可以获取到对应的通道，管道中维护了很多的处理器。
Netty 示例
实现服务器与客户端的通讯
引入Netty依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.43.Final</version>
</dependency>
服务器端代码：
public class NettyServer {
public static void main(String[] args) {
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
NioEventLoopGroup workGroup = new NioEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workGroup) //设置两个线程组
.option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列得到连接个数
.channel(NioServerSocketChannel.class)//使用 NioSocketChannel 作为服务器的通道实现
.childHandler(new ChannelInitializer<SocketChannel>() {//创建一个通道测试对象(匿名对象)
//给 pipeline 设置处理器
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new NettyServerHandler());
}
});// 给我们的 workerGroup 的 EventLoop 对应的管道设置处理器
//绑定一个端口并且同步, 生成了一个 ChannelFuture 对象,启动服务器(并绑定端口)
ChannelFuture channelFuture = bootstrap.bind(6668).sync();
//对关闭通道进行监听
channelFuture.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
}
}
}
//处理器
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
/**
* 读取客户端发送的消息
*
* @param ctx 上下文对象 含有管道pipeline 通道channel
* @param msg 客户端发送的数据
* @throws Exception
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("服务器读取线程:" + Thread.currentThread().getName());
System.out.println("server ctx:" + ctx);
Channel channel = ctx.channel();
System.out.println("channel：" + channel);
ChannelPipeline pipeline = ctx.pipeline();
System.out.println("pipeline:" + pipeline);
ByteBuf byteBuf = (ByteBuf) msg;
System.out.println("客户端发送消息是" + byteBuf.toString(CharsetUtil.UTF_8));
System.out.println("客户端地址:" + channel.remoteAddress());
}
//数据读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//将数据写入缓存并刷新
//一般 我们对这个发送的数据进行编码
ctx.writeAndFlush(Unpooled.copiedBuffer("我来自服务端，我收到了你的消息",CharsetUtil.UTF_8));
}
//处理异常 一般需要关闭通道
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
客户端代码：
public class NettyClient {
public static void main(String[] args) {
//客户端需要一个事件循环组
EventLoopGroup group = new NioEventLoopGroup();
try {
//创建客户端启动对象
//注意客户端使用的不是 ServerBootstrap 而是 Bootstrap
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group) //设置线程组
.channel(NioSocketChannel.class) // 设置客户端通道的实现类(反射)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new NettyClientHandler());//加入自己的处理器
}
});
//启动客户端去连接服务器端
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
//给关闭通道设置监听
channelFuture.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
group.shutdownGracefully();
}
}
}
//处理器
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
//当通道就绪就会触发该方法
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("client：" + ctx);
ctx.writeAndFlush(Unpooled.copiedBuffer("我是客户端，我要发送消息了", CharsetUtil.UTF_8));
}
//当通道有读取事件时 会触发
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf byteBuf = (ByteBuf) msg;
System.out.println("服务器回复的消息:" + byteBuf.toString(CharsetUtil.UTF_8));
System.out.println("服务器的地址" + ctx.channel().remoteAddress());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
可以发现，开发人员只需要关注特定的事件就好了，其他的Netty给进行了封装，相较于NIO还是很方便的。
