NettyTimeServer
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public class NettyTimeServer {
private void bind(int port) throws Exception {
/**
* NioEventLoopGroup 就是NIO的异步线程组，包含了一组NIO线程，专门处理网络事件，实际上就是Reactor线程组
*
* bossGroup： 用来接受客户端的连接
* workerGroup：用于SocketChannel的网络读写
*
*/
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
/**
* ServerBootstrap 这个类是NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
*
*/
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup) // 两个线程组传入
.channel(NioServerSocketChannel.class) // 设置Channel为 NioServerSocketChannel
.option(ChannelOption.SO_BACKLOG, 1024) // 设置 tcp参数，backlog，这里为 1024
.childHandler(new TimeServerChannelHandler()) // 绑定IO事件处理类，主要用来处理网络IO事件，例如记录日志，对消息进行编码等
.childOption(ChannelOption.SO_KEEPALIVE, true);
// 绑定端口，同步等待成功
ChannelFuture future = serverBootstrap.bind(port).sync();
// 等待服务器监听端口关闭
future.channel().closeFuture().sync();
} catch (Exception e) {
// TODO: handle exception
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
int port = 8080;
if (args != null && args.length > 0) {
try {
port = Integer.parseInt(args[0]);
} catch (Exception e) {
// TODO: handle exception
}
}
new NettyTimeServer().bind(port);
}
}
TimeServerChannelHandler
import java.util.Date;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
* 用来处理网络事件的读写操作
* 只需要关注 channelRead 和 exceptionCaught 方法
*/
public class TimeServerChannelHandler extends ChannelInboundHandlerAdapter {
/**
*
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // (2)
/**
* ByteBuf 类似jdk的 ByteBuffer，功能更加强大灵活
*
* buf.readableBytes()：获取缓冲区可读的字节数
*
*
*/
ByteBuf buf = (ByteBuf) msg;
byte[] req = new byte[buf.readableBytes()]; // 根据可读的字节数创建byte数组
buf.readBytes(req); // 将缓冲区中的字节数组复制到新建的byte数组中
String body = new String(req, "UTF-8"); // 获取请求的消息
System.out.println("The time server receive order : " + body);
/**
* 如果消息是 QUERY TIME ORDER， 则创建应答消息
*/
String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date().toString() : "BAD ORDER";
/**
* 将应答消息转化为 ByteBuf
*/
ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
ctx.write(resp); // 异步发送应答消息给客户端
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
System.out.println("channelReadComplete");
/**
* 该方法的作用是将消息发送队列中的消息写入到 SocketChannel 中发送给对方
* 从性能角度考虑：为了防止频繁地唤醒Selector进行消息发送，Netty的write方法并不直接将消息写入SocketChannel中，
* 调用 write 方法只是把待发送的消息发到发送缓冲数组中，再通过调用 flush 方法，将发送缓冲区中的消息
* 全部写到 SocketChannel 中
*/
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // (4)
cause.printStackTrace();
ctx.close();
}
}
NettyTimeClient
import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;
public class NettyTimeClient {
private void connect(int port, String host) throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group).channel(NioSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true)
.handler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new TimeClientHandler());
}
});
// 发起异步连接操作
ChannelFuture future = bootstrap.connect(host, port).sync();
// 等待客户端链路关闭
future.channel().closeFuture().sync();
} catch (Exception e) {
} finally {
group.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
int port = 8080;
if (args != null && args.length > 0) {
try {
port = Integer.parseInt(args[0]);
} catch (Exception e) {
// TODO: handle exception
}
}
new NettyTimeClient().connect(port, "127.0.0.1");
}
}
TimeClientHandler
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
* 重点关注 channelActive channelRead exceptionCaught
*
*
*/
public class TimeClientHandler extends ChannelInboundHandlerAdapter {
// private static final Logger.get
private final ByteBuf firstMessage;
public TimeClientHandler() {
byte[] req = "QUERY TIME ORDER".getBytes();
firstMessage = Unpooled.buffer(req.length);
firstMessage.writeBytes(req);
}
/**
* 当客户端和服务端TCP链路建立成功之后，Netty线程会调用 channelActive 方法
* 发送查询事件的指令给服务端，调用 ChannelHandlerContext 的 writeAndFlush 方法将请求消息发送给服务端
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.writeAndFlush(firstMessage);
}
/**
* 当服务端返回应答消息时，channelRead 方法被调用，
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
byte[] req = new byte[buf.readableBytes()];
buf.readBytes(req);
String body = new String(req, "UTF-8");
System.out.println("Now is :" + body);
}
/**
* 发生异常时，调用该方法，打印异常日志
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}