netty-第一个案例

netty-第一个demo

netty

搭建环境

maven引入

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.12.Final</version>
</dependency>

服务端

Netty 服务器都需要以下两部分

至少一个 ChannelHandler — 该组件实现了服务器对从客户端接收的数据的处理，即它的业务逻辑。
引导 — 这是配置服务器的启动代码。至少，它会将服务器绑定到它要监听连接请求的端口上

channelHandler

@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter { 
    // 对于每个传入的消息都要调用
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
        ByteBuf in = (ByteBuf) msg;
        System.out.println("server recevied:"+ in.toString(StandardCharsets.UTF_8));
        ctx.write(in);
    }
    // 通知ChannelInboundHandler最后一次对channel-
    //Read()的调用是当前批量读取中的最后一条消息
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }
    // 在读取操作期间，有异常抛出时会调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
        System.out.println("读取操作错误信息");
        cause.printStackTrace(); //打印错误
        ctx.close();//关闭channel
    }
}

BootStrap

public class EchoServer { 
    private final int port;
    public EchoServer(int port) { 
        this.port = port;
    }
    public static void main(String[] args) throws InterruptedException { 
        int port = Integer.parseInt("1234");
        new EchoServer(port).start();
    }
//绑定到服务器将在其上监听并接受传入连接请求的端口；
//配置 Channel ，以将有关的入站消息通知给 EchoServerHandler 实例
    private void start() throws InterruptedException { 
        final EchoServerHandler serverHandler = new EchoServerHandler();
        NioEventLoopGroup group = new NioEventLoopGroup();
        try { 
        ServerBootstrap b  = new ServerBootstrap(); //创建bootstrap
        b.group(group)
                .channel(NioServerSocketChannel.class) //使用nio传输channel
                .localAddress(port)  // 绑定端口
                .childHandler(new ChannelInitializer<SocketChannel>() { 
                    // 添加一个EchoServer-
                    //Handler 到子Channel
                    //的 ChannelPipeline
            @Override
            protected void initChannel(SocketChannel ch) throws Exception { 
                ch.pipeline().addLast(serverHandler);
                // EchoServerHandler被标注为@Shareable，所以我们可以总是使用同样的实例
            }
        });
// 异步地绑定服务器；调用 sync()方法阻塞等待直到绑定完成
            ChannelFuture f = b.bind().sync();
// 获取 Channel 的CloseFuture，并且阻塞当前线程直到它完成
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }finally { 
            group.shutdownGracefully().sync();
        }
    }
}

客户端

EchoClientHandler

@Sharable
public class EchoClientHandler
    extends SimpleChannelInboundHandler<ByteBuf> { 
    @Override
    public void channelActive(ChannelHandlerContext ctx) { 
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!",
                CharsetUtil.UTF_8));
    }
    @Override
    public void channelRead0(ChannelHandlerContext ctx, ByteBuf in) { 
        System.out.println(
                "Client received: " + in.toString(CharsetUtil.UTF_8));
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx,
        Throwable cause) { 
        cause.printStackTrace();
        ctx.close();
    }
}

BootStrap

public class EchoClient { 
    private final String host;
    private final int port;
    public EchoClient(String host, int port) { 
        this.host = host;
        this.port = port;
    }
    public static void main(String[] args) throws InterruptedException { 
        final String host = "127.0.0.1";
        final int port = Integer.parseInt("1234");
        new EchoClient(host, port).start();
    }
    private void start() throws InterruptedException { 
        NioEventLoopGroup group = new NioEventLoopGroup();
        try { 
        Bootstrap b = new Bootstrap();
        b.group(group)
                .channel(NioSocketChannel.class)
                .remoteAddress(host,port)
                .handler(new ChannelInitializer<SocketChannel>() { 
            @Override
            protected void initChannel(SocketChannel ch) throws Exception { 
                ch.pipeline().addLast(new EchoClientHandler());
            }
        });
            ChannelFuture future = b.connect().sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }finally { 
            group.shutdownGracefully().sync();
        }
    }
}