Netty 是由 JBOSS 提供的基于NIO一个 Java 开源网络编程框架。Netty 提供异步的、基于事件驱动的网络应用程序框架,用以快速开发高性能、高可靠性的网络 IO 程序。作为当前最流行的 NIO 框架,Netty应用很广泛, hadoop、dubbo等底层RPC都是基于Netty实现的。以下是实现的章节:
在学习了NIO的基础知识和Netty的设计思想,对于Netty的初识只差这临门一脚。先来看下利用Netty编写的入门案例实现步骤:
核心API介绍:
主要包括ChannelHandler及实现类ChannelInboundHandlerAdapter,Pipeline 和 和 ChannelPipeline,ChannelHandlerContext,ChannelOption、
ChannelHandler 及其实现类
ChannelHandler 接口定义了许多事件处理的方法,在实际的应用过程中我们经常需要自定义一个 Handler 类去继承 ChannelInboundHandlerAdapter,然后通过重写相应方法实现业务逻辑,我们接下来看看一般都需要重写哪些方法:
- public void channelActive(ChannelHandlerContext ctx),通道就绪事件
- public void channelRead(ChannelHandlerContext ctx, Object msg),通道读取数据事件
- public void channelReadComplete(ChannelHandlerContext ctx) ,数据读取完毕事件
- public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause),通道发生异常事件
Pipeline 和 和 ChannelPipeline
ChannelPipeline 是一个 Handler 的集合,它负责处理和拦截 inbound 或者 outbound 的事件和操作,相当于一个贯穿 Netty 的链。
- ChannelPipeline addFirst(ChannelHandler... handlers),把一个业务处理类(handler)添加到链中的第一个位置
- ChannelPipeline addLast(ChannelHandler... handlers),把一个业务处理类(handler)添加到链中的最后一个位置
ChannelHandlerContext
这是事件处理器上下文对象,Pipeline 链中的实际处理节点。每个处理节点ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler , 同 时ChannelHandlerContext 中也绑定了对应的 pipeline 和 Channel 的信息,方便对 ChannelHandler进行调用。常用方法如下所示:
- ChannelFuture close(),关闭通道
- ChannelOutboundInvoker flush(),刷新
- ChannelFuture writeAndFlush(Object msg) , 将 数 据 写 到 ChannelPipeline 中 当 前
- ChannelHandler 的下一个 ChannelHandler 开始处理(出站)
ChannelOption
Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。ChannelOption 是Socket 的标准参数,而非 Netty 独创的。常用的参数配置有:
- 1. ChannelOption.SO_BACKLOG对应 TCP/IP 协议 listen 函数中的 backlog 参数,用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。多个客户端来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理,backlog 参数指定了队列的大小。
- 2. ChannelOption.SO_KEEPALIVE ,一直保持连接活动状态。
ChannelFuture
表示 Channel 中异步 I/O 操作的结果,在 Netty 中所有的 I/O 操作都是异步的,I/O 的调用会直接返回,调用者并不能立刻获得结果,但是可以通过 ChannelFuture 来获取 I/O 操作的处理状态。
常用方法如下所示:
- Channel channel(),返回当前正在进行 IO 操作的通道
- ChannelFuture sync(),等待异步操作执行完毕
EventLoopGroup 和其实现类 NioEventLoopGroup
EventLoopGroup 是一组 EventLoop 的抽象,Netty 为了更好的利用多核 CPU 资源,一般会有多个 EventLoop 同时工作,每个 EventLoop 维护着一个 Selector 实例。EventLoopGroup 提供 next 接口,可以从组里面按照一定规则获取其中一个 EventLoop
来处理任务。在 Netty 服务器端编程中,我们一般都需要提供两个 EventLoopGroup,例如:BossEventLoopGroup 和 WorkerEventLoopGroup。通常一个服务端口即一个ServerSocketChannel对应一个Selector和一个EventLoop线程。BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进行 IO 处理,如下图所示:
BossEventLoopGroup 通常是一个单线程的 EventLoop,EventLoop 维护着一个注册了ServerSocketChannel 的 Selector 实例,BossEventLoop 不断轮询 Selector 将连接事件分离出来,通常是 OP_ACCEPT 事件,然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup,WorkerEventLoopGroup 会由 next 选择其中一个 EventLoopGroup 来将这个 SocketChannel 注
册到其维护的 Selector 并对其后续的 IO 事件进行处理。
常用方法如下所示:
- public NioEventLoopGroup(),构造方法
- public Future<?> shutdownGracefully(),断开连接,关闭线程
ServerBootstrap 和 和 Bootstrap
ServerBootstrap 是 Netty 中的服务器端启动助手,通过它可以完成服务器端的各种配置;Bootstrap 是 Netty 中的客户端启动助手,通过它可以完成客户端的各种配置。常用方法如下所示:
- public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup),
该方法用于服务器端,用来设置两个 EventLoop
- public B group(EventLoopGroup group) ,该方法用于客户端,用来设置一个 EventLoop
- public B channel(Class<? extends C> channelClass),该方法用来设置一个服务器端的通道实现
- public <T> B option(ChannelOption<T> option, T value),用来给 ServerChannel 添加配置
- public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value),用来给接收到的通道添加配置
- public ServerBootstrap childHandler(ChannelHandler childHandler),该方法用来设置业务
处理类(自定义的 handler)
- public ChannelFuture bind(int inetPort) ,该方法用于服务器端,用来设置占用的端口号
- public ChannelFuture connect(String inetHost, int inetPort) ,该方法用于客户端,用来连接服务器端
Unpooled 类
这是 Netty 提供的一个专门用来操作缓冲区的工具类,常用方法如下所示:
- public static ByteBuf copiedBuffer(CharSequence string, Charset charset),通过给定的数据和字符编码返回一个 ByteBuf 对象(类似于 NIO 中的 ByteBuffer 对象)
服务端NettyServer代码实现:
1、创建两个两个NioEventLoopGroup实例,NioEve ntLoopGroup是一个线程组,包含了一组NIO线程,专门用于网络事件的处理,实际就是Reactor线程组,这里面一个线程组bossGroup用来接收客户端连接,一个线程组workerGroup用来处理通道IO操作。
2、创建ServerBootstrap对象,它是Netty用于启动NIO服务端的辅助启动类,目的是降低服务端的开发复杂度。调用group方法,将两个线程组作为参数传入 ;调用channel方法,使用NioServerSocketChannel作为服务器通道实现;调用option方法,设置线程队列中的等待的连接个数;调用childOption方法,保持活动连接状态;调用childHandler方法,创建一个通道初始化对象,在 Pipeline 链中添加自定义的业务处理 handler;
3、启动服务器端并绑定端口,等待接受客户端连接(非阻塞)
4、关闭连接,关闭连接池
代码实现:
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
/**
* Netty服务类
* @author Administrator
*
*/
public class NettyServer {
public static void main(String[] args) throws Exception {
//1.创建一个线程组:用来处理网络事件(接受客户端连接)
EventLoopGroup bossGroup = new NioEventLoopGroup();
//2.创建一个线程组:用来处理网络事件(处理通道 IO 操作)
EventLoopGroup workerGroup = new NioEventLoopGroup();
//3.创建服务器端启动助手来配置参数
ServerBootstrap b = new ServerBootstrap();
//使用 NioServerSocketChannel 作为服务器端通道实现
b.group(bossGroup, workerGroup);
b.channel(NioServerSocketChannel.class)//5.使用 NioServerSocketChannel 作为服务器端通道实现
.option(ChannelOption.SO_BACKLOG, 128)//6.设置线程队列中等待连接的个数
.childOption(ChannelOption.SO_KEEPALIVE, true) //7.保持活动连接状态
.childHandler(new ChannelInitializer<SocketChannel>() { //8.创建一个通道初始化对象
public void initChannel(SocketChannel sc) {//9.往 Pipeline 链中添加自定义的业务处理 handle
sc.pipeline().addLast(new NettyServerHandler()); //服务器端业务处理类
}
});
//10.启动服务器端并绑定端口,等待接受客户端连接(非阻塞)
ChannelFuture cf = b.bind(9999).sync();
System.out.println("......Server is Starting......");
//11.关闭通道,关闭线程池
cf.channel().closeFuture().sync();
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
实现服务端NettyServerHandler业务处理类:
1、继承自ChannelHandlerAdapter,它用于对网络事件进行读写操作,通常我们只需要关注channelRead和exceptionCaught方法。
2、channelRead读取数据事件
3、数据读取完毕事件
4、异常情况处理
代码实现:
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override //读取数据事件
public void channelRead(ChannelHandlerContext ctx, Object msg) {
System.out.println("Server: " + ctx);
ByteBuf buf = (ByteBuf) msg;
System.out.println("客户端发来的消息 : " + buf.toString(CharsetUtil.UTF_8));
}
@Override //数据读取完毕事件
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.writeAndFlush(Unpooled.copiedBuffer("就是没钱", CharsetUtil.UTF_8));
}
@Override //异常发生事件
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
客户端NettyClient实现过程:
1、设置一个线程组EventLoopGroup 线程组
2、创建客户端启动助手Bootstrap,调用group方法将线程组传入,调用channel方法实现NioSocketChannel客户端通道;调用handler方法,实现通道处理化对象,在Pipeline 链中添加自定义的业务处理 handler。
3、启动客户端连接(非阻塞);
4、等待连接关闭(非阻塞)。
代码实现:
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
/**
* Netty客户端代码实现
* @author Administrator
*
*/
public class NettyClient {
public static void main(String[] args) throws Exception {
//1.创建一个 EventLoopGroup 线程组
EventLoopGroup group = new NioEventLoopGroup();
//2.创建客户端启动助手
Bootstrap b = new Bootstrap();
b.group(group) //3.设置 EventLoopGroup 线程组
.channel(NioSocketChannel.class) //4.使用 NioSocketChannel 作为客户端通道实现
.handler(new ChannelInitializer<SocketChannel>() { //5.创建一个通道初始化对象
@Override
protected void initChannel(SocketChannel sc) { //6.往 Pipeline 链中添加自定义的业务处理 handler
sc.pipeline().addLast(new NettyClientHandler()); //客户端业务处理类
System.out.println("......Client is ready.......");
}
});
//7.启动客户端,等待连接上服务器端(非阻塞)
ChannelFuture cf = b.connect("127.0.0.1", 9999).sync();
//8.等待连接关闭(非阻塞)
cf.channel().closeFuture().sync();
}
}
客户端事件处理类NettyClientHandler实现思路:
1、继承自ChannelHandlerAdapter,它用于对网络事件进行读写操作,通常我们只需要关注channelRead和exceptionCaught方法。
2、channelRead读取数据事件
3、数据读取完毕事件
4、异常情况处理
代码实现:
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
/**
* 自定义客户端事件处理类
* @author Administrator
*
*/
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
@Override //通道就绪事件
public void channelActive(ChannelHandlerContext ctx) {
System.out.println("Client: " + ctx);
ctx.writeAndFlush(Unpooled.copiedBuffer("老板,还钱吧", CharsetUtil.UTF_8));
}
@Override //通道读取数据事件
public void channelRead(ChannelHandlerContext ctx, Object msg) {
ByteBuf in = (ByteBuf) msg;
System.out.println("服务器端发来的消息 : " + in.toString(CharsetUtil.UTF_8));
}
@Override //数据读取完毕事件
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.flush();
}
@Override //异常发生事件
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
ctx.close();
}
}
以上就是Netty一个简单的入门案例,和单纯的NIO编程,代码更简洁,释义更清楚。不过在进行通讯过程中, 常见的拆包和黏包的问题并没有在上述案例中体现,究竟为什么会产生拆包和黏包的问题,而Netty有什么好的解决策略?这两个问题值得思考一下。