package com.fly;

import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

/**
 * 使用Netty实现一个Hello服务,支持服务端与客户端简单的消息收发
 */
public class HelloServer {
    public static void main(String[] args) {
        /**
         * 创建两个EventLoopGroup(事件循环组),在Netty中,服务器通常接收两类任务:接收连接和处理连接的IO操作,
         * 为了高效地处理这些任务,Netty使用不同的线程组来分离接收连接和处理 I/O 操作的任务,以此
         * 来提高服务器的并发性能。其中:
         * - bossGroup:该线程组负责接受传入的连接。它会监听服务器绑定的端口,并接受客户端的连接请求。
         * 一旦有新的连接建立,bossGroup 将其注册到 workerGroup 中的线程进行进一步处理。
         * - workerGroup:该线程组负责处理已经建立的连接的 I/O 操作。一旦连接被接受并注册到
         * workerGroup 中,workerGroup 将负责处理连接的读取和写入操作。
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 创建ServerBootstrap对象,用于配置和启动服务器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 设置线程模型,Netty内部使用基于事件驱动和多线程的线程模型,称为 Reactor 线程模型
            serverBootstrap.group(bossGroup, workerGroup)
                    /**
                     * 设置通信通道(Channel),Channel是Netty中提供的一个抽象接口,
                     * 表示一个开放的连接,可以进行数据的读取和写入。Channel提供了
                     * 多个子接口以适应不同的网络通信需求和协议,常见的子接口如下:
                     * - SocketChannel:用于 TCP 网络套接字的 Channel 实现。
                     * 它提供了对 TCP 连接的读取和写入操作,以及对连接状态的管理。
                     * - ServerChannel:用于监听传入连接的 Channel 实现。
                     * 它可以接受传入的连接请求，并创建相应的 SocketChannel 用于处理这些连接。
                     * - UdtChannel:用于支持 UDT（User Datagram Protocol for Transactions）
                     * 协议的通信。UDT 是一种可靠的、高性能的数据传输协议,特别适用于对传输延迟
                     * 和可靠性有严格要求的应用。
                     * - DatagramChannel:用于 UDP 数据报套接字的 Channel 实现。
                     * 它提供了对 UDP 数据包的读取和写入操作，以及对多播和广播的支持。
                     *
                     * 其中SocketChannel接口的具体实现如下:
                     * - NioServerSocketChannel:基于 Java NIO 的 SocketChannel 实现,适用于 TCP 网络套接字。
                     * - OioSocketChannel:基于传统的阻塞 I/O 的 SocketChannel 实现,适用于旧版的 I/O 模型。
                     * - EpollSocketChannel:基于 Linux Epoll 的 SocketChannel 实现，
                     * 适用于 TCP 网络套接字。它提供了更高的性能和可伸缩性
                     */
                    .channel(NioServerSocketChannel.class)
                    /**
                     * handler()用于向 ChannelPipeline 末尾添加一个新的 ChannelHandler。
                     * ChannelHandler 是 Netty 中的处理器，用于实现具体的业务逻辑和数据处理。
                     * 它可以处理不同类型的事件，如连接建立、数据读取、数据写入等，并进行相应的操作和响应。
                     * 通过添加不同的 ChannelHandler，可以实现各种功能，如数据解码、数据编码、
                     * 业务逻辑处理、错误处理、日志记录等。
                     *
                     * ChannelPipeline 是 Netty 中的一个重要概念，它由一系列的 ChannelHandler
                     * 组成，用于处理传入和传出的数据、事件和状态变化。在ChannelPipeline中
                     * ChannelHandler被组织成一个处理链，用于对Channel的数据流进行处理。
                     * 当一个事件或数据通过ChannelPipeline传递时，会被依次经过各个ChannelHandler进行处理和转换。
                     */
                    .handler(new LoggingHandler(LogLevel.INFO))
                    /**
                     * childHandler() 方法是用于向 ServerChannel 的 ChildChannelPipeline 末尾
                     * 添加一个新的 ChannelHandler。在 Netty 的服务器端，通常会有一个
                     * ServerChannel 负责监听和接受客户端的连接请求。一旦有新的连接建立，
                     * ServerChannel 会创建一个对应的子 Channel，即 ChildChannel。ChildChannel
                     * 用于处理与客户端之间的具体通信，包括数据的读写和事件的处理。
                     * 与 handler() 方法不同，childHandler() 方法是针对每个新连接的子 Channel 进行处理，
                     * 而不是整个 ChannelPipeline。每个新连接都会有自己独立的 ChildChannelPipeline，
                     * 并且可以根据需要定制不同的数据处理逻辑。
                     *
                     * ChannelInitializer 是 Netty 中的一个特殊的 ChannelHandler，用于在 Channel 被注册到 EventLoop
                     * 后,对 Channel 进行初始化和配置。ChannelInitializer支持在Channel 注册后自定义配置 ChannelPipeline,
                     * 添加一系列的 ChannelHandler 来处理传入和传出的数据、事件和状态变化。ChannelInitializer抽象类提供了
                     * initChannel()方法用于自定义的 Channel 初始化逻辑,在initChannel方法中可以向 ChannelPipeline
                     * 添加各种 ChannelHandler，并配置它们的顺序和参数。
                     */
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        /**
                         * initChannel()方法自定义的 Channel 初始化逻辑
                         * @param ch           已注册的Channel
                         * @throws Exception
                         */
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 通过Channel获取Channel管道
                            ChannelPipeline pipeline = ch.pipeline();
                            // 在通道管道尾部添加通道处理器(ChannelHandler)
                            pipeline.addLast(new StringDecoder()); // 添加字符串解码器
                            pipeline.addLast(new StringEncoder()); // 添加字符串编码器
                            pipeline.addLast(new HelloServerHandler()); // 添加自定义处理器
                        }
                    });
                    // 绑定端口
                    serverBootstrap.bind(8888)
                            /**
                             * sync()用于阻塞等待服务器的启动完成。sync()返回一个ChannelFuture
                             * ,表示服务器的异步操作结果。
                             */
                            .sync()
                            // 获取Channel
                            .channel()
                            // 用于获取表示Channel关闭的ChannelFuture对象
                            .closeFuture()
                            .sync();

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            /**
             * 释放资源。Netty提供了shutdownGracefully()和shutdownNow()用于关闭EventLoopGroup,
             * 两者区别如下:
             * - shutdownGracefully():用于优雅地关闭 Netty 的 EventLoopGroup,
             * shutdownGracefully()会等待所有正在处理的任务完成后再关闭 EventLoopGroup,而
             * - shutdownNow():用于立即关闭 Netty 的 EventLoopGroup,shutdownNow()并不会
             * 等待正在处理的任务完成。它会强制停止所有的线程，并丢弃尚未完成的任务。
             * 除此之外,Netty还提供了isShutdown()、isShuttingDown()判断EventLoopGroup是否被终结。
             */
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package com.fly;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * 自定义ChannelHandler(需要实现ChannelHandler接口),实现消息的收发。
 * SimpleChannelInboundHandler是ChannelInboundHandlerAdapter 的一个子类,
 * 间接性实现了ChannelHandler接口,用于处理特定类型的消息。SimpleChannelInboundHandler
 * 允许接收一个泛型,表示处理的消息类型。
 */
public class HelloServerHandler extends SimpleChannelInboundHandler<String> {

    /**
     * 用于处理接收到的消息
     * @param ctx           ChannelHandler上下文
     * @param msg           接收的消息
     * @throws Exception
     */
    @Override
    protected void messageReceived(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("receive client message:" + msg);
        /**
         * 将数据写入到与ChannelHandlerContext关联的Channel并刷新数据,
         * 注意:ChannelHandlerContext的write()只是将消息写入到对应的Channel的缓冲区中,
         * 并不会将消息发送至客户端,若要发送消息请使用flush()。flush()的作用是将
         * 所有待发送的数据从内部缓冲区刷新到底层的Socket缓冲区中,并尽可能快地发送给客户端。
         * writeAndFlush()用于向对象Channel写入数据,并将Channel中的数据刷新到底层的
         * Socket缓冲区中发送。
         *
         * Socket是计算机网络通信中的一种编程接口(网络通讯中抽象概念,表示一个网络连接的一端),它提供了一种
         * 通过网络进行数据传输的机制,用于在不同计算机之间建立网络连接,实现数据的发送和接收。
         * Socket编程可以用于各种网络协议,如TCP/IP、UDP、HTTP等。它提供了一种灵活的方式来实现网络应用程序,
         * 例如客户端-服务器模型、点对点通信等。
         */
        ctx.writeAndFlush("client reply message:I'm fine");
    }
}

package com.fly.reactor.single;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 单Reactor单线程模型,Reactor和Handler在同一个线程中,Reactor负责监听连接,
 * 收到连接后在同一个线程处理请求,虽然实现简单但无法实现异步和并发处理。
 */
public class SingleThreadReactor {
    /**
     * ServerSocket用于服务端提供网络服务,它工作在传输层(TCP)并负责建立Socket连接
     */
    private ServerSocket serverSocket;

    public SingleThreadReactor(int port) throws IOException {
        this.serverSocket = new ServerSocket(port);
    }

    public void serve() {
        // 如果serverSocket连接未关闭,则一直阻塞等待处理请求
        while (!serverSocket.isClosed()) {
            try {
                /**
                 * 阻塞等待会一直等待客户端连接,当接收到客户端连接请求时,会返回一个
                 * 新的Socket实例,Socket与指定客户端建立了点对点连接,可以用来发送接收数据。
                 * Socket与指定客户端建立了点对点连接,可以用来发送接收数据,
                 * 可以通过设置backlog参数来配置等待连接队列的大小
                 */
                Socket socket = serverSocket.accept();
                handleRequest(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    void handleRequest(Socket socket) throws IOException {
        // 从Socket(套接字)获取输入流
        InputStream input = socket.getInputStream();
        // 根据输入流创建一个只读输入流
        InputStreamReader streamReader = new InputStreamReader(input, "UTF-8");
        OutputStream output = socket.getOutputStream();
        OutputStreamWriter streamWriter = new OutputStreamWriter(output, "UTF-8");
        /**
         * 根据Reader流创建缓冲区读取字符流,BufferedReader实现了缓冲读取机制,它会一次性读取大块
         * 数据到缓冲区,然后应用可以从缓冲区获取数据,实现了读取性能的大幅提升
         */
        BufferedReader reader = new BufferedReader(streamReader);
        /**
         * readLine()用于从字符输入流中读取一行内容,如果流中没有数据,
         * readLine()会进行阻塞等待
         */
        String message = reader.readLine();
        System.out.println("message:" + message);
        /**
         * PrintWriter类封装了输出流,提供了格式化打印字符串的高效便捷接口,
         * 支持所有基本数据类型、String、对象、char[]等多种数据类型输出。
         * PrintWriter使用内部缓存区存储数据以减少写操作的次数,以此来提高性能,
         * 并且支持自动刷新数据到Socket,无需手动flush。
         */
        PrintWriter writer = new PrintWriter(streamWriter, true);
        // 向客户端写入数据
        writer.println("Hello Client:" + message);
        reader.close();
        // 关闭套接字
        socket.close();
    }
}

package com.fly.reactor.single;


import java.io.IOException;

/**
 * 单Reactor单线程模型启动类
 */
public class SingleThreadReactorBootstrap {
    public static void main(String[] args) throws IOException {
        SingleThreadReactor reactor = new SingleThreadReactor(8888);
        reactor.serve();
    }
}

// 通过EventLoopGroup构造方法传入1表示单线程模式
EventLoopGroup group = new NioEventLoopGroup(1);
ServerBootstrap bootstrap = new ServerBootstrap();
// 配置线程模型
bootstrap.group(group);

/**
 * NioEventLoopGroup创建的线程数与以下几个参数相关:
 * - ioRatio:IO任务和非IO任务的执行线程数比例,默认8。
 *
 * - 初始化线程数:NioEventLoopGroup(int nThreads)支持构造函数
 * 指定初始化的线程数,默认是CPU核心数 * 2。
 *
 * - 启动时线程数:在Netty服务启动时,会调用NioEventLoopGroup的next()
 * 方法获取下一个EventLoop来处理Channel。这个过程中会延迟创建线程,
 * 线程数取决于处理的Channel数。
 *
 * - 最大线程数:通过调用setMaximumPoolSize()可以限制EventLoop的最大线程数。
 *
 * - 线程增长步长:在运行时可以通过步长逐渐增加线程数,防止创建过多空闲线程。
 */
EventLoopGroup group = new NioEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
// 配置线程模型为单Reactor多线程模型
bootstrap.group(group);

/**
 * 创建两个EventLoopGroup,主Reactor负责接受传入的连接,用于分配给从Reactor,
 * 从Reactor用于IO处理
 */
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup);