一、什么是Netty
Netty是一个JAVA开源框架,提供异步、事件驱动的网络应用程序框架和工具。
二、Netty组件
1、Bootstrap
启动辅助器,Netty客户端和服务器的入口,Bootstrap是创建客户端连接的启动器,ServerBootstrap是监听服务端端口的启动器。
2、EventLoop
(1)类似线程,一个EventLoopGroup包含一个或者多个EventLoop。
(2)通过EventLoopGroup(Bootstrap启动时会设置EventLoopGroup)生成。
(3)一个EventLoop在它的生命周期内只和一个Thread绑定。
(4)所有由EventLoop处理的IO事件都将在它专有的Thread上被处理。
(5)一个Channel在它的生命周期内只注册于一个EventLoop。
(6)一个EventLoop可能会被分配一个或多个Channel。
(7)EventLoop内部有一个无限循环,维护了一个selector,处理所有注册到selector上的IO操作,在这里实现了一个线程维护多条连接的工作。
3、ByteBuf
(1)提供了对TCP、UDP和文件传输的支持。
(2)使用更高效的socket底层,对epoll空轮询引起的CPU占用飙升在内部进行了处理,避免了直接使用NIO的陷阱,简化了NIO的处理方式。
(3)采用多种decoder/encoder 支持,对TCP粘包/分包进行自动化处理。
(4)可使用线程池,提高连接效率。
(5)可配置IO线程数、TCP参数, TCP接收和发送缓冲区使用直接内存代替堆内存,通过内存池的方式循环利用ByteBuf。
(6)通过引用计数器及时申请释放不再引用的对象,降低GC频率。
(7)使用单线程串行化的方式,是高效的Reactor线程模型。
(8)大量使用了volitale、CAS和原子类、线程安全类、读写锁。
4、Channel
(1)常用的是NioServerSocketChannel和NioSocketChannel。
(2)NioServerSocketChannel负责监听一个tcp端口,有连接进来通过boss reactor创建一个NioSocketChannel将其绑定到worker reactor,然后worker reactor负责这个NioSocketChannel的读写等IO事件。
5、ChannelPipeline
(1)ChannelPipeline内部有两个节点:head和tail,分别对应着ChannelHandler链的头和尾。
(2)write、read、connect等所有IO操作都会通过ChannelPipeline。
(3)依次通过ChannelPipeline上面的ChannelHandler处理,是Netty模型的核心。
6、ChannelHandler
(1)Netty中真正的IO事件处理单元,可以创建自己的ChannelHandler来处理自己的逻辑,完全控制事件的处理方式。
(2)ChannelHandler分为inBound和outBound,分别对应IO的read和write执行链。
(3)ChannelHandler和ChannelPipeline组成责任链,使得一组ChannelHandler像一条链一样执行下去。
(4)ChannelHandler用ChannelHandlerContext包裹着,有prev和next节点,可以获取前后ChannelHandler,read时从ChannelPipeline的head执行到tail,write时从tail执行到head,所以head既是read事件的起点也是write事件的终点。
三、特点
1、统一的API,适用于不同的协议。
2、基于灵活、可扩展的事件驱动模型。
3、高度可定制的线程模型。
4、可靠的无连接数据Socket支持。
5、更好的吞吐量,低延迟,更省资源,减少不必要的内存拷贝。
6、安全易用。
四、使用Netty
1、引入依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.10.Final</version>
</dependency>
2、服务端编程
(1)具体流程
实例化两个EventLoopGroup事件循环组,一个boss事件循环组用于接收客户端连接,一个worker事件循环组用于处理连接;
实例化服务端的启动辅助类ServerBootstrap,配置group组、指定主事件循环组的channel类型、worker处理的chanlerHandler;
启动服务端,serverBootstrap.bind().sync(); 其中sync()方法保证服务端完全启动(否则会阻塞)。
(2)代码实现
EchoNettyServerDemo类:
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
public class EchoNettyServerDemo {
public static void main(String[] args) {
//实例化EventLoopGroup
//服务端实例化两个事件循环组
//其中Boss事件循环组用于接收客户端连接(accept)
//Worker事件循环组用于处理连接(channel交给worker循环组)
//reactor网络模型
EventLoopGroup boss=new NioEventLoopGroup();
EventLoopGroup worker=new NioEventLoopGroup(5);
try {
//实例化服务端的启动辅助类(服务端相关配置、操作都交给启动辅助类)
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap
//配置事件循环组
.group(boss,worker)
//指定主事件循环组
.channel(NioServerSocketChannel.class)
//自定义childHandler实现具体的业务处理逻辑
.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel ch) throws Exception {
//pipeline是容器,所有的channel通过该容器
ChannelPipeline pipeline=ch.pipeline();
//编码解码
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
//自定义channelHandler
pipeline.addLast(new EchoServerHandler());
}
});
//通过sync方法启动服务端,作用是同步阻塞直至服务端完全启动(这步操作才结束)否则被阻塞,一句话,为了完全启动
ChannelFuture sync = serverBootstrap.bind(8888).sync();
System.out.println("服务端启动");
//关闭channel
//关闭操作会阻塞,直到通道完全关闭
sync.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
boss.shutdownGracefully();
worker.shutdownGracefully();
}
}
}
EchoServerHandler类:
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import java.net.SocketAddress;
//接收消息的channelHandler需要实现ChannelInboundHandler接口
//该接口下提供了很多方法,只需实现方法就可以接收消息
//可以在自定义的类中进行重写以实现特定需求
public class EchoServerHandler extends SimpleChannelInboundHandler<String> {
//父类是一个抽象方法,子类要进行重写
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, String s) throws Exception {
}
//重写父类的channelRead方法用来接收数据
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println(ctx.channel().remoteAddress() + "发送消息:" + msg);
//接收消息并返回给客户端
ctx.writeAndFlush("echo:" + msg);
}
//客户端下线
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
SocketAddress socketAddress = ctx.channel().remoteAddress();
System.out.println(socketAddress+"客户端下线");
}
//客户端上线
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
SocketAddress socketAddress = ctx.channel().remoteAddress();
System.out.println(socketAddress+"客户端上线");
}
}
3、客户端编程
(1)具体流程
实例化事件循环组EventLoopGroup组;
实例化启动服务类Bootstrap,配置group组、指定channel类型、配置channelHandler;
同步连接服务端;
向服务端发送消息。
(2)代码实现
EchoNettyClientDemo类:
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.util.Scanner;
public class EchoNettyClientDemo {
public static void main(String[] args) {
//启动事件循环组
NioEventLoopGroup loopGroup = new NioEventLoopGroup();
//启动辅助类
Bootstrap bootstrap = new Bootstrap();
try {
//配置启动辅助类
Bootstrap channel = bootstrap
//配置事件循环组
.group(loopGroup)
//指定通道类型
.channel(NioSocketChannel.class)
//配置通道
.handler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//编码解码
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
//接受服务端返回的消息
//自定义Handler
pipeline.addLast(new EchoClientHandler());
}
});
//客户端连接服务端
Channel channel1 = bootstrap.connect("127.0.0.1", 8888).sync().channel();
System.out.println("客户端已连接上");
//channel1.writeAndFlush("hello");
while(true) {
System.out.println("请输入:");
Scanner s = new Scanner(System.in);
String msg = s.nextLine();
channel1.writeAndFlush(msg);
if("exit".equals(msg)){
break;
}
}
//关闭通道
channel1.closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
loopGroup.shutdownGracefully();
}
}
}
EchoClientHandler类:
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
public class EchoClientHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
}
//重写方法用于接收消息
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//打印服务端返回的消息
System.out.println(msg);
}
}
3、运行结果
先启动EchoNettyServerDemo类后启动EchoNettyClientDemo类,然后在客户端输入消息,服务端可接收到。