Netty 黑马

public class EventLoopClient {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        // 1. 启动类
        ChannelFuture channelFuture = new Bootstrap()
                // 2. 添加 EventLoop
                .group(group)
                // 3. 选择客户端 channel 的实现
                .channel(NioSocketChannel.class)
                // 4. 添加处理器
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override  // 连接建立后被调用
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringEncoder());  // 将字符串转换为字节数组
                    }
                })
                // 5. 连接服务端，这一步是「异步非阻塞」的，main 发起了调用，真正执行 connect 的是 nio 线程
                .connect(new InetSocketAddress("127.0.0.1", 8080));

        Channel channel = channelFuture
                .sync()  // 处理方法 1: 阻塞当前线程，直到 nio 线程连接成功
                .channel();

        // 从控制台发送消息
        new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String msg = scanner.nextLine();
                if ("q".equals(msg)) {
                    channel.close(); // 是异步操作
                    break;
                }
                channel.writeAndFlush(msg);
            }
        }, "input").start();

        // 1) 同步处理方法
        ChannelFuture closeFuture = channel.closeFuture();
        System.out.println("waiting for close");
        closeFuture.sync();
        System.out.println("处理关闭后的操作");
        group.shutdownGracefully();

        // 2) 异步处理方法
        /*closeFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                System.out.println("异步处理关闭后的操作");
                group.shutdownGracefully();
            }
        });*/


        // 6. 向服务器发送数据
//        channel.writeAndFlush("Hello Netty");

        // 处理方法 2: 使用 addListener 回调对象）方法，异步处理结果
        /*channelFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Channel channel = future.channel();
                System.out.println(channel);
                channel.writeAndFlush("Hello Netty");
            }
        });*/

    }
}

public class TestNettyPromise {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. 准备 EventLoop 对象
        EventLoop eventLoop = new NioEventLoopGroup().next();

        // 2. 可以主动创建 promise
        DefaultPromise<Object> promise = new DefaultPromise<>(eventLoop);

        new Thread(()-> {
            // 3. 任意线程执行计算，计算完毕后向 promise 写入结果
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            promise.setSuccess(80);
        }).start();

        // 4. 接收结果
        System.out.println("等待结果");
        System.out.println("结果为：" + promise.get());
    }
}