八.Netty入门到超神系列-Netty入门&核心类
前言
上一章讨论的是Netty的线程模型，这一章我们基于上一章的线程模型来实战一把。由于Netty5出现重大BUG被官方废弃，所以我们使用Netty4进行学习。
Netty入门实战
在开始之前再来看一下Netty的线程模型
我们需要有GoosGroup来循环监听请求事件，需要有WorkGroup来处理事件，而这两个角色都通过来就NioEventLoopGroup来进行事件监听，我们还需要创建事件处理器ChannelHandler,通过 Channel的ChannelPipeline把ChannelHandler进行关联。
导入依赖
我们来写一个简单的服务端和客户端通信的案例，首先创建Maven项目，导入Maven依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.42.Final</version>
</dependency>
服务端代码
对于服务端我们要做如下事情
- 创建两个NioEventLoopGroup ,一个作为BossGroup ，一个作为 WorkGroup
- 创建 ServerBootstrap 加入两个NioEventLoopGroup
- 通过 ServerBootstrap 添加Handler ，需要自己创建Handler
- 编写Handler ，通过继承ChannelInboundHandlerAdapter 来对不同的事件做不同的处理
服务端代码如下
public class NettyServer {
public static void main(String[] args) throws InterruptedException {
//创建Boss Group ：负责处理链接
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
//创建 workGroup ：负责处理读写事件
NioEventLoopGroup workGroup = new NioEventLoopGroup();
//创建服务端启动对象
ServerBootstrap bootstrap = new ServerBootstrap();
try{
//把 bossGroup 和 workGroup 加入启动对象
bootstrap
.group(bossGroup,workGroup)
//保存活动链接状态，启用该功能时，TCP会主动探测空闲连接的有效性
.childOption(ChannelOption.SO_KEEPALIVE,true)
//多个客户端过来，处理不过来的请求在队列排队，指定存放请求的队列的大小
.option(ChannelOption.SO_BACKLOG,64)
//指定服务器使用什么样的通道
.channel(NioServerSocketChannel.class)
//添加事件处理器Handler
.childHandler(new ChannelInitializer<SocketChannel>(){
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//把处理器添加进去 , 每个channel都对应一个pieline
//pieline通道和Handler进行绑定，通过Pieline可以获取到Handler
ch.pipeline().addLast(new MyServerHandler());
}
});
//绑定端口，开始接收客户端请求
//bind方法中会创建 Channel，然后使用 EventLoop注册Channel
ChannelFuture future = bootstrap.bind(new InetSocketAddress("127.0.0.1", 6000)).sync();
//对关闭通道进行监听
//当此通道关闭时将收到通知
future.channel().closeFuture().sync();
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭资源
workGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}
- ChannelOption.SO_BACKLOG：服务端处理客户端连接请求是顺序处理的，所以同一事件只能处理一个客户端连接，多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog参数指定了队列的大小
- ChannelOption.SO_KEEPALIVE：当设置该选项以后，如果在两小时内没有数据的通信时，TCP会自动发送一个活动探测数据报文。
handler代码如下
//这个Handler是用来处理客户端channel的IO事件
public class MyServerHandler extends ChannelInboundHandlerAdapter {
//处理读事件 ChannelHandlerContext ：上下文，含有通道，pipline ,地址 ； msg就是数据
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buffer = (ByteBuf) msg;
System.out.println("MyServerHandler,接收到:"+ctx.channel().remoteAddress()+"发来的消息："+buffer.toString(CharsetUtil.UTF_8));
}
//数据读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//给客户端恢复消息
ctx.writeAndFlush(Unpooled.copiedBuffer("你好，我收到了消息",CharsetUtil.UTF_8));
}
}
上面有几个陌生的类
- ChannelInboundHandlerAdapter ：这个是为Channel通道绑定处理事件的Handler,用来接收请求。
- ByteBuf ：Netty提供的byte缓冲区
- Unpooled.copiedBuffer ：工具，把数据拷贝到ByteBuf
客户端代码
客户端要做如下事情
- 创建 NioEventLoopGroup 用于监听服务端的事件
- 创建 Bootstrap启动对象 ，加入 NioEventLoopGroup
- 一样要通过 Bootstrap 添加Handler ，需要自己创建Handler
- 编写Handler ，通过继承ChannelInboundHandlerAdapter 来对不同的事件做不同的处理
客户端代码如下
public class NettyClient {
public static void main(String[] args) throws InterruptedException {
//客户端线程循环组
NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
//客户端启动对象
Bootstrap bootstrap = new Bootstrap();
try {
bootstrap.group(eventExecutors)
//指定客户端使用的通道类型
.channel(NioSocketChannel.class)
//添加客户端处理器
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//添加客户端处理器
ch.pipeline().addLast(new MyClientHandler());
}
});
//链接服务端
ChannelFuture channelFuture = bootstrap
.connect(new InetSocketAddress("127.0.0.1", 6000)).sync();
//监听关闭事件
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
eventExecutors.shutdownGracefully();
}
}
}
客户端handler代码如下
//这个Handler是用来处理客户端channel的IO事件
public class MyClientHandler extends ChannelInboundHandlerAdapter {
//链接激活
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
//给服务端发送消息
ctx.writeAndFlush(Unpooled.copiedBuffer("你好服务端",CharsetUtil.UTF_8));
}
//处理读事件 ChannelHandlerContext ：上下文，含有通道，pipline ,地址 ； msg就是数据
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buffer = (ByteBuf) msg;
System.out.println("MyClientHandler,接收到:"+ctx.channel().remoteAddress()+"发来的消息："+buffer.toString(CharsetUtil.UTF_8));
}
//处理异常
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
分别启动服务端和客户端，最终效果如下
- 服务端
- 客户端
核心类认识
在上面的入门案例中涉及到一些类，这里做一个解释
NioEventLoopGroup
NioEventLoopGroup 继承于 EventLoopGroup ，代表Nio 事件循环组，用来循环监听注册的Channel的IO事件，如上图，我们需要两个NioEventLoopGroup，一个为BossGroup做事件监听 ，一个为 WorkGroup做事件监听
ServerBootstrap，Bootstrap
ServerBootstrap是Netty服务端启动引导对象 ，Bootstrap是客户端的启动引导对象，作用都差不多，主要是用来配置整个netty程序,整合各个组件。
ServerBootstrap 常用方法如下：
- group(EventLoopGroup parentGroup, EventLoopGroup childGroup) ： 该方法用于服务端，主要是为 BossGroup(Acceptor) 设置 EventLoopGroup 来监听连接事件，以及为 WorkGroup 设置EventLoopGroup来监听读写事件。
- channel(Class channelClass) : 指定用来创建channel通道实例的class
- option(ChannelOption option, T value) : 方法的作用是用来给ServerChannel添加配置项
- childOption(ChannelOption childOption, T value) :为请求的channel添加配置项
- handler(ChannelHandler handler) : 给BossGrop添加Handler
- childHandler(ChannelHandler childHandler) : 给WorkGroup添加Handler
- bind(InetAddress inetHost, int inetPort) : 为服务端绑定监听的地址和端口
Bootstrap 常用方法如下
- connect(InetAddress inetHost, int inetPort) ：用来连接服务端
- group(EventLoopGroup group) : 为客户端添加EventLoopGroup事件循环组。
Future,ChannelFuture
由于Netty的IO是异步的，不能立即得到消息是否被处理完成，所以需要通过Future,ChannelFuture 注册事件监听，当操作完成后会触发相应的事件，从而对事件结果做出相应的处理。
Channel
通道，用来关联IO操作和处理的Handler,不同的协议有不同的Channel
- NioServerSocketChannel : 服务端的TCP Socket 连接
- NioSocketChannel ：客户端的TCP Socket连接
ChannelHandler
ChannelHandler是用来处理IO事件的Handler，Handler实际上分为两种，Inbound 入站和Outbound出站，ChannelHandler比较常用的有如下两个子类
-
ChannelInboundHandlerAdapter
该适配器 实现了ChannelInboundHandler 接口，ChannelInboundHandler 又实现了ChannelHandler接口，主要是用来处理IO入站事件
-
ChannelOutboundHandlerAdapter
适配器 实现了ChannelOutboundHandler，ChannelOutboundHandler又实现了 ChannelHandler接口，它主要是用处理IO出站事件
-
ChannelDuplexHandler ：双通道处理器，它同时实现了ChannelInboundHandler 和 ChannelOutboundHandler ，既可以处理IO入站事件，也可以处理IO出站事件。
ChannelPipeline
对于每个新的通道Channel，都会创建一个新的ChannelPipeline，并将器pipeline附加到channel中，可以把ChannelPipeline看成是一个ChandlerHandler的链表，当有事件发生的时候，Pipeline负责依次调用每一个Handler进行处理或截获通道的接收和发送数据，ChannelPipeline 通过 ChannelHandlerContext来管理ChannelHandler
下面是端点后的 ChannelPipeline的调用链截图
通过Cahnnel可以获取到ChannelPipeline，通过ChannelPipeline也可以获取到Channel,ChannelPipeline是ChandlerHandler形成的双向链表 ，ChandlerHandler中包含了真正的Handler , 上图的Head是头节点，tail是尾节点 。 如下图：
所以整个IO事件的处理是通过 Channel ,ChannelPipeline 和 Handler 三者一起来完成的。这里要注意的是，如果事件运动方向是从客户端到服务端，数据会通过pipeline中的一些列的OutboundHandler进行处理，事件被称之为出站，反之就是入站。两种类型的Handller相互不影响
Unpooled
Unpooled是Netty提供的buffer缓冲工具类，可以根据给定的数据和编码创建一个ByteBuf，如 ByteBuf buffer = Unpooled.buffer(1024);。ByteBuf类似于NIO中的ByteBuffer 。区别在于ByteBuffer需要调用flip()读写转换，而ByteBuf无需转换。
和ByteBuffer一样，ByteBuf中维护了一个byte[]来存储数据，同时还维护了一个writerIndex和readerIndex,当执行 buffer.writeByte 写操作writerIndex就会向后移动，指向下一个存储位置。当执行 buffer.readByte()操作的时候readerIndex就会向后移动指向下一个读的位置。当readerIndex等于writerIndex，ByteBuf中的数据读取完成。
文章到这就结束了，点赞还是要求一下的，万一屏幕面前的大帅哥，或者大漂亮一不小心就一键三连了啦，那我就是熬夜到头发掉光，也出下章