feat(新增): 🚀 测试出栈入栈

netty/service/src/test/java/cn/bunny/demo6/TestEmbedded.java

@@ -0,0 +1,47 @@
+package cn.bunny.demo6;
+
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+
+public class TestEmbedded {
+    public static void main(String[] args) {
+        ChannelInboundHandlerAdapter h1 = new ChannelInboundHandlerAdapter() {
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                System.out.println(1);
+                ctx.fireChannelRead(msg); // 1
+            }
+        };
+        ChannelInboundHandlerAdapter h2 = new ChannelInboundHandlerAdapter() {
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                System.out.println(2);
+                ctx.channel().write(msg); // 2
+            }
+        };
+
+        ChannelOutboundHandlerAdapter h3 = new ChannelOutboundHandlerAdapter() {
+            @Override
+            public void write(ChannelHandlerContext ctx, Object msg,
+                              ChannelPromise promise) {
+                System.out.println(4);
+                ctx.write(msg, promise); // 3
+            }
+        };
+
+        ChannelOutboundHandlerAdapter h4 = new ChannelOutboundHandlerAdapter() {
+            @Override
+            public void write(ChannelHandlerContext ctx, Object msg,
+                              ChannelPromise promise) {
+                System.out.println(5);
+                ctx.write(msg, promise); // 4
+            }
+        };
+        EmbeddedChannel channel = new EmbeddedChannel(h1, h2, h3, h4);
+        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes("hello world".getBytes()));
+    }
+}

netty/service/src/test/java/cn/bunny/demo6/TestNettyPromise.java

@@ -0,0 +1,35 @@
+package cn.bunny.demo6;
+
+import io.netty.channel.EventLoop;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.util.concurrent.DefaultPromise;
+import io.netty.util.concurrent.Promise;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.concurrent.ExecutionException;
+
+@Slf4j
+public class TestNettyPromise {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        // 准备EventLoop 对象
+        EventLoop eventLoop = new NioEventLoopGroup().next();
+        // 可以创建promise 结果容器
+        Promise<Integer> promise = new DefaultPromise<>(eventLoop);
+
+        new Thread(() -> {
+            // 任意线程进行计算
+            System.out.println("开始计算...");
+            // 计算完成后向promise填充结果
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException exception) {
+                exception.printStackTrace();
+            }
+
+            promise.setSuccess(80);
+        }).start();
+        // 除了可以等待结果，也可以处理异常
+        log.debug("等待结果...");
+        log.debug("结果是：{}", promise.get());
+    }
+}

netty/service/src/test/java/cn/bunny/demo6/TestPipelineDemo.java

@@ -0,0 +1,67 @@
+package cn.bunny.demo6;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class TestPipelineDemo {
+    public static void main(String[] args) {
+        new ServerBootstrap()
+                .group(new NioEventLoopGroup())
+                .channel(NioServerSocketChannel.class)
+                .childHandler(new ChannelInitializer<NioSocketChannel>() {
+                    protected void initChannel(NioSocketChannel ch) {
+                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
+                            @Override
+                            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                                System.out.println(1);
+                                ctx.fireChannelRead(msg); // 1
+                            }
+                        });
+                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
+                            @Override
+                            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                                System.out.println(2);
+                                ctx.fireChannelRead(msg); // 2
+                            }
+                        });
+                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
+                            @Override
+                            public void channelRead(ChannelHandlerContext ctx, Object msg) {
+                                System.out.println(3);
+                                ctx.channel().write(msg); // 3
+                            }
+                        });
+                        ch.pipeline().addLast(new ChannelOutboundHandlerAdapter() {
+                            @Override
+                            public void write(ChannelHandlerContext ctx, Object msg,
+                                              ChannelPromise promise) {
+                                System.out.println(4);
+                                ctx.write(msg, promise); // 4
+                            }
+                        });
+                        ch.pipeline().addLast(new ChannelOutboundHandlerAdapter() {
+                            @Override
+                            public void write(ChannelHandlerContext ctx, Object msg,
+                                              ChannelPromise promise) {
+                                System.out.println(5);
+                                ctx.write(msg, promise); // 5
+                            }
+                        });
+                        ch.pipeline().addLast(new ChannelOutboundHandlerAdapter() {
+                            @Override
+                            public void write(ChannelHandlerContext ctx, Object msg,
+                                              ChannelPromise promise) {
+                                System.out.println(6);
+                                ctx.write(msg, promise); // 6
+                            }
+                        });
+                    }
+                })
+                .bind(8080);
+    }
+}