Netty简介
- Netty是一款基于NIO(Nonblocking I/O,非阻塞IO)开发的网络通信框架,提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。对比于BIO(Blocking I/O,阻塞IO),他的并发性能得到了很大提高。
- 提供了对TCP、UDP和文件传输的支持,作为一个异步NIO框架,Netty的所有IO操作都是异步非阻塞的,通过Future-Listener机制,用户可以方便的主动获取或者通过通知机制获得IO操作结果。
- 优势:①并发高;②传输快;③封装好,易开发。
Netty的部分构件
-
Channel
在Netty里,Channel是Netty网络通信的载体、主体,由它负责同对端进行网络通信、注册和数据操作等功能。- 状态主要包括:打开、关闭、连接。
- 主要的IO操作:读(read)、写(write)、连接(connect)、绑定(bind)。
- 所有的IO操作都是异步的,调用诸如read,write方法后,并不保证IO操作完成,但会返回一个凭证,在IO操作成功,取消或失败后会记录在该凭证中。
-
ChannelPipeline
- 可以理解为ChannelHandler的容器:一个Channel包含一个ChannelPipeline,所有ChannelHandler都会注册到ChannelPipeline中,并按顺序组织起来。channel事件消息在ChannelPipeline中流动和传播,相应的事件能够被ChannelHandler拦截处理、传递、忽略或者终止。
- Netty的ChannelPipeline包含两条线路:Upstream和Downstream。Upstream对应上行,接收到的消息、被动的状态改变,都属于Upstream。Downstream则对应下行,发送的消息、主动的状态改变,都属于Downstream。
-
ChannelHandler
- ChannelHandler负责Channel中的逻辑处理,即对I/O事件或者I/O操作进行拦截和处理,用户可以通过ChannelHandlerAdapter来选择性的实现自己感兴趣的事件拦截和处理。由于Channel只负责实际的I/O操作,因此数据的编解码和实际处理都需要通过ChannelHandler进行处理。
Netty实现TCP Server 和 Client 的通信
- 依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.10.Final</version>
<scope>compile</scope>
</dependency>
- Server (编解码需要的话自行实现)
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;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class NettyServer {
public void bind(int port) throws Exception {
//bossGroup就是parentGroup,是负责处理TCP/IP连接的
EventLoopGroup bossGroup = new NioEventLoopGroup();
//workerGroup就是childGroup,是负责处理Channel(通道)的I/O事件
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap sb = new ServerBootstrap();
sb.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
//初始化服务端可连接队列,指定了队列的大小5000
.option(ChannelOption.SO_BACKLOG, 5000)
//保持长连接
.childOption(ChannelOption.SO_KEEPALIVE, true)
// 绑定客户端连接时候触发操作
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel sh) throws Exception {
sh.pipeline()
// .addLast(new RpcDecoder(RpcRequest.class)) //解码request
// .addLast(new RpcEncoder(RpcResponse.class)) //编码response
.addLast(new ServerHandler()); //使用ServerHandler类来处理接收到的消息
}
});
//绑定监听端口,调用sync同步阻塞方法等待绑定操作完
ChannelFuture future = sb.bind(port).sync();
if (future.isSuccess()) {
log.info("服务端启动成功");
} else {
log.info("服务端启动失败");
future.cause().printStackTrace();
bossGroup.shutdownGracefully(); //关闭线程组
}
//成功绑定到端口之后,给channel增加一个 管道关闭的监听器并同步阻塞,直到channel关闭,线程才会往下执行,结束进程。
future.channel().closeFuture().sync();
}
}
- ServerHandler
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;
import java.net.SocketAddress;
@Slf4j
public class ServerHandler extends ChannelInboundHandlerAdapter {
/**
* 接受client发送的消息
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//传来的消息包装成字节缓冲区
ByteBuf byteBuf = (ByteBuf) msg;
SocketAddress socketAddress = ctx.channel().remoteAddress();
//Netty提供了字节缓冲区的toString方法,并且可以设置参数为编码格式:CharsetUtil.UTF_8
log.info("客户端地址:{},消息:{}", socketAddress, byteBuf.toString(CharsetUtil.UTF_8));
//返回数据
// ctx.writeAndFlush("");
}
/**
* 通知处理器最后的channelRead()是当前批处理中的最后一条消息时调用
*/
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
log.info("服务端接收数据完毕..");
ctx.flush();
}
/**
* 读操作时捕获到异常时调用
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
ctx.close();
}
/**
* 客户端和服务端连接成功时触发
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// ctx.writeAndFlush("hello client");
}
}
- NettyClient
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
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.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
public class NettyClient {
private final String host;
private final int port;
private Channel channel;
//连接服务端的端口号地址和端口号
public NettyClient(String host, int port) {
this.host = host;
this.port = port;
}
public void start() throws Exception {
final EventLoopGroup group = new NioEventLoopGroup();
Bootstrap b = new Bootstrap();
b.group(group).channel(NioSocketChannel.class) // 使用NioSocketChannel来作为连接用的channel类
.handler(new ChannelInitializer<SocketChannel>() { // 绑定连接初始化器
@Override
public void initChannel(SocketChannel ch) throws Exception {
System.out.println("正在连接中...");
ChannelPipeline pipeline = ch.pipeline();
// pipeline.addLast(new RpcEncoder(RpcRequest.class)); //编码request
// pipeline.addLast(new RpcDecoder(RpcResponse.class)); //解码response
pipeline.addLast(new ClientHandler()); //客户端处理类
}
});
//发起异步连接请求,绑定连接端口和host信息
final ChannelFuture future = b.connect(host, port).sync();
future.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture arg0) throws Exception {
if (future.isSuccess()) {
System.out.println("连接服务器成功");
} else {
System.out.println("连接服务器失败");
future.cause().printStackTrace();
group.shutdownGracefully(); //关闭线程组
}
}
});
this.channel = future.channel();
}
public Channel getChannel() {
return channel;
}
}
- ClientHandler
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
public class ClientHandler extends SimpleChannelInboundHandler<T>{
//处理服务端返回的数据
@Override
protected void channelRead0(ChannelHandlerContext ctx, T data) throws Exception {
System.out.println("接受到server响应数据: " + data.toString());
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
super.channelActive(ctx);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
- NettyServer 的启动
new NettyServer().bind(8080);
- NettyClient 的启动
import io.netty.channel.Channel;
public class Main {
public static void main(String[] args) throws Exception {
NettyClient client = new NettyClient("127.0.0.1", 8080);
//启动client服务
client.start();
Channel channel = client.getChannel();
//channel对象可保存在map中,供其它地方发送消息
channel.writeAndFlush(“发送内容”);
}
}
参考资料:https://blog.csdn.net/qq_22200097/article/details/83042424