编写Netty程序
编写代码
1.创建线程池
一般来说，我们会声明两个线程池，一个线程池用来处理Accept事件，一个是用于处理消息的读写事件。
// 用来处理Accept事件
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
// 用来处理消息的读写时间
EventLoopGroup workerGroup = new NioEventLoopGroup();
一般我们只需要监听一个端口，所以bossGroup一般声明为1个线程，bossGroup接收到新的连接后会交给workerGroup处理，workerGroup负责监听这些连接的读写事件。
2.创建启动类
启动类有两个，客户端启动类Bootstrap，服务端启动类ServerBootstrap，启动类负责整个Nett 程序的正常运行。
以服务端为例
ServerBootstrap serverBootstrap = new ServerBootstrap();
3.设置线程池
把第一步声明的线程池设置到ServerBootstrap中， bossGroup负责监听Accept连接，workerGroup负责监听连接的读写数据。
serverBootstrap.group(bossGroup, workerGroup)
4.设置ServerSocketChannel
设置Netty程序以什么样的IO模型运行，以NioServerSocketChannel为例
serverBootstrap.channel(NioServerSocketChannel.class);
如果程序运行在Linux系统上，可以使用EpollServerSocketChannel，它使用的是Linux系统上的epoll模型，比select 模型更高效。
这里提到的IO模型是指IO多路复用模型，一共有三个类型：select、poll、epoll。
select 实现多路复用的方式是，将已连接的Socket都放到一个文件描述符集合，然后调用select函数将文件描述符集合拷贝到内核里，让内核来检查是否有网络事件产生，检查的方式很粗暴，就是通过遍历文件描述符集合的方式，当检查到有事件产生后，将此 Socket 标记为可读或可写， 接着再把整个文件描述符集合拷贝回用户态里，然后用户态还需要再通过遍历的方法找到可读或可写的 Socket，然后再对其处理。
所以，对于 select 这种方式，需要进行 2 次「遍历」文件描述符集合，一次是在内核态里，一个次是在用户态里 ，而且还会发生 2 次「拷贝」文件描述符集合，先从用户空间传入内核空间，由内核修改后，再传出到用户空间中。
select 使用固定长度的 BitsMap，表示文件描述符集合，而且所支持的文件描述符的个数是有限制的，在 Linux 系统中，由内核中的 FD_SETSIZE 限制， 默认最大值为 1024，只能监听 0~1023 的文件描述符。
poll 不再用 BitsMap 来存储所关注的文件描述符，取而代之用动态数组，以链表形式来组织，突破了 select 的文件描述符个数限制，当然还会受到系统文件描述符限制。
但是 poll 和 select 并没有太大的本质区别，都是使用「线性结构」存储进程关注的 Socket 集合，因此都需要遍历文件描述符集合来找到可读或可写的 Socket，时间复杂度为 O(n)，而且也需要在用户态与内核态之间拷贝文件描述符集合，这种方式随着并发数上来，性能的损耗会呈指数级增长。
epoll 通过两个方面，很好解决了 select/poll 的问题。
第一点，epoll 在内核里使用红黑树来跟踪进程所有待检测的文件描述字，把需要监控的 socket 通过 epoll_ctl() 函数加入内核中的红黑树里，红黑树是个高效的数据结构，增删查一般时间复杂度是 O(logn)，通过对这棵黑红树进行操作，这样就不需要像 select/poll 每次操作时都传入整个 socket 集合，只需要传入一个待检测的 socket，减少了内核和用户空间大量的数据拷贝和内存分配。
第二点， epoll 使用事件驱动的机制，内核里维护了一个链表来记录就绪事件，当某个 socket 有事件发生时，通过回调函数内核会将其加入到这个就绪事件列表中，当用户调用 epoll_wait() 函数时，只会返回有事件发生的文件描述符的个数，不需要像 select/poll 那样轮询扫描整个 socket 集合，大大提高了检测的效率。
原文链接：https://blog.csdn.net/qq_34827674/article/details/115619261
5.设置可选参数
设置Netty中可以使用的参数，这些参数都在ChannelOption及其子类中。
这里设置了一个SO_BACKLOG系统参数，它表示的是最大等待连接数量。
serverBootstrap.option(ChannelOption.SO_BACKLOG, 100);
6.设置可选Handler
只能设置一个，它会在SocketChannel建立起来之前执行，后面再分析它的执行时机。
serverBootstrap.handler(new LoggingHandler(LogLevel.INFO))
7.编写并设置子Handler
Netty中的Handler分成两种，一种叫做Inbound，一种叫做Outbound。
这里简单地写一个Inbound类型的Handler，它把接收到数据直接写回给客户端。
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
// 读取数据后写回客户端
ctx.write(msg);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
设置子Handler 设置的是SocketChannel对应的Handler，也是只能设置一个，它用于处理SocketChannel的事件。
serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
// 可以添加多个子Handler
p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new EchoServerHandler());
}
});
虽然只能设置一个子Handler，但是Netty提供了一种可以设置多个Handler的途径，即使用ChannelInitializer方式，第六步设置 Handler也可以使用这种方式设置多个Handler。
这里，我们设置了一个打印日志的LoggingHandler和一个自定义的EchoServerHandler。
8.绑定端口
ChannelFuture f = serverBootstrap.bind(PORT).sync();
9.等待服务端端口关闭
等待服务端监听端口关闭，sync () 会阻塞主线程，内部调用的是 Object 的 wait () 方法。
f.channel().closeFuture().sync();
10.关闭线程池
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
上面设置了ServerSocketChannel的类型，而没有设置SocketChannel的类型。
是因为SocketChannel是ServerSocketChannel在接受连接之后创建出来的，所以，并不需要单独再设置它的类型，比如，NioServerSocketChannel创建出来的肯定是NioSocketChannel，而EpollServerSocketChannel创建出来的肯定是 EpollSocketChannel。
完整代码
服务端代码
/**
* 1.打开命令行窗口: telnet localhost 8001
* 2.进入发送消息模式: Ctrl + ]
* 3.使用send命令发送消息: send hello
*/
public class EchoServer {
static final int PORT = 8001;
public static void main(String[] args) {
// 1. 声明线程池
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
// 2. 服务端引导器
ServerBootstrap serverBootstrap = new ServerBootstrap();
// 3. 设置线程池
serverBootstrap.group(bossGroup, workerGroup)
// 4. 设置ServerSocketChannel的类型
.channel(NioServerSocketChannel.class)
// 5. 设置参数
.option(ChannelOption.SO_BACKLOG, 100)
// 6. 设置ServerSocketChannel对应的Handler，只能设置一个
.handler(new LoggingHandler(LogLevel.INFO))
// 7. 设置SocketChannel对应的Handler
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
// 可以添加多个子Handler
// p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new EchoServerHandler());
}
});
// 8. 绑定端口
ChannelFuture f = serverBootstrap.bind(PORT).sync();
// 9. 等待服务端监听端口关闭，这里会阻塞主线程
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 10. 优雅地关闭两个线程池
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
EchoServerHandler
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
// 读取数据后写回客户端
ctx.write(msg);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
客户端代码
public class NettyClient {
static final int PORT = 8001;
public static void main(String[] args) throws Exception {
// 工作线程池
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup);
bootstrap.channel(NioSocketChannel.class);
bootstrap.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// pipeline.addLast(new LoggingHandler(LogLevel.INFO));
pipeline.addLast(new NettyClientHandler());
}
});
// 连接到服务端
ChannelFuture future = bootstrap.connect(new InetSocketAddress(PORT)).sync();
System.out.println("connect to server success");
// 调用后这里会阻塞
// future.channel().closeFuture().sync();
// 这里实现可以在控制台输入发送信息
Channel channel = future.channel();
Scanner scanner = new Scanner(System.in);
while (true) {
String msg = scanner.nextLine();
channel.writeAndFlush(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8));
if ("quit".equals(msg)) {
channel.close();
break;
}
}
} finally {
workerGroup.shutdownGracefully();
}
}
}
NettyClientHandler
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println(LocalDateTime.now().toString() + " " + ctx.channel() + " " + ((ByteBuf)msg).toString(CharsetUtil.UTF_8));
}
}
Netty实现群聊
NettyChatHolder
public class NettyChatHolder {
static final Map<SocketChannel, Long> userMap = new ConcurrentHashMap<>();
private static AtomicLong userIdList = new AtomicLong(10000);
static void join(SocketChannel socketChannel) {
// 有人加入就给他分配一个id
Long userId = userIdList.addAndGet(1);
send(socketChannel, "userId:" + userId);
for (SocketChannel channel : userMap.keySet()) {
send(channel, userId + " 加入了群聊");
}
// 将当前用户加入到map中
userMap.put(socketChannel, userId);
}
private static void send(SocketChannel socketChannel, String msg) {
try {
ByteBufAllocator allocator = ByteBufAllocator.DEFAULT;
ByteBuf writeBuffer = allocator.buffer(msg.getBytes().length);
writeBuffer.writeCharSequence(msg, Charset.defaultCharset());
socketChannel.writeAndFlush(writeBuffer);
} catch (Exception e) {
e.printStackTrace();
}
}
static void quit(SocketChannel socketChannel) {
Long userId = userMap.get(socketChannel);
send(socketChannel, "您退出了群聊");
userMap.remove(socketChannel);
for (SocketChannel channel : userMap.keySet()) {
if (channel != socketChannel) {
send(channel, userId + " 退出了群聊");
}
}
}
public static void propagate(SocketChannel socketChannel, String content) {
Long userId = userMap.get(socketChannel);
for (SocketChannel channel : userMap.keySet()) {
if (channel != socketChannel) {
send(channel, userId + ":" + content);
}
}
}
}
NettyChatHandler
public class NettyChatHandler extends SimpleChannelInboundHandler<ByteBuf> {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
SocketChannel socketChannel = (SocketChannel)ctx.channel();
System.out.println("one conn active: " + socketChannel);
// socketChannel是在ServerBootstrapAcceptor中放到EventLoopGroup中的
NettyChatHolder.join(socketChannel);
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf byteBuf) throws Exception {
/***
* 如果这里有耗时操作的话, 可以自定义一个线程池来处理这下面的逻辑
*/
byte[] bytes = new byte[byteBuf.readableBytes()];
byteBuf.readBytes(bytes);
String content = new String(bytes, StandardCharsets.UTF_8);
System.out.println(ctx.channel() + ":" + content);
if (content.equals("quit")) {
ctx.channel().close();
} else {
NettyChatHolder.propagate((SocketChannel) ctx.channel(), content);
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
SocketChannel socketChannel = (SocketChannel)ctx.channel();
System.out.println("one conn inactive: " + socketChannel);
NettyChatHolder.quit((SocketChannel) ctx.channel());
}
}
NettyChatServer
public class NettyChatServer {
static final int PORT = Integer.parseInt(System.getProperty("port", "8001"));
public static void main(String[] args) {
// 1. 声明线程池
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
// 2. 服务端引导器
ServerBootstrap serverBootstrap = new ServerBootstrap();
// 3. 设置线程池
serverBootstrap.group(bossGroup, workerGroup)
// 4. 设置ServerSocketChannel的类型
.channel(NioServerSocketChannel.class)
// 5. 设置参数
.option(ChannelOption.SO_BACKLOG, 100)
// 6. 设置ServerSocketChannel对应的Handler，只能设置一个
.handler(new LoggingHandler(LogLevel.INFO))
// 7. 设置SocketChannel对应的Handler
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
// 可以添加多个子Handler
p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new NettyChatHandler());
}
});
// 8. 绑定端口
ChannelFuture f = serverBootstrap.bind(PORT).sync();
// 9. 等待服务端监听端口关闭，这里会阻塞主线程
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 10. 优雅地关闭两个线程池
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
Netty版本
<dependency>
<groupId>io.nettygroupId>
<artifactId>netty-allartifactId>
<version>4.1.63.Finalversion>
dependency>