创建安全的 Netty 程序

1.使用 SSL/TLS 创建安全的 Netty 程序

SSL 和 TLS 是众所周知的标准和分层的协议，它们可以确保数据时私有的

Netty提供了SSLHandler对网络数据进行加密

使用Https

public class SslChannelInitialzer extends ChannelInitializer<Channel>{

    private final SSLContext context;
    private final boolean client;
    private final boolean startTls;

    public SslChannelInitialzer(SSLContext context, boolean client, boolean startTls) {
        this.context = context;
        this.client = client;
        this.startTls = startTls;
    }

    @Override
    protected void initChannel(Channel ch) throws Exception {
        SSLEngine engine = context.createSSLEngine();
        engine.setUseClientMode(client);
        ch.pipeline().addFirst("ssl", new SslHandler(engine, startTls));
    }

}

2.使用 Netty 创建 HTTP/HTTPS 程序

public class HttpDecoderEncodeIntializer extends ChannelInitializer<Channel>{

    private final boolean client;

    public HttpDecoderEncodeIntializer(boolean client) {
        this.client = client;
    }

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        if (client) {
            pipeline.addLast("decoder", new HttpResponseDecoder());
            pipeline.addLast("", new HttpRequestEncoder());
　　　　　　　pipeline.addLast("decompressor", new HttpContentDecompressor()); //添加解压缩 Handler
        } else {
            pipeline.addLast("decoder", new HttpRequestEncoder());
            pipeline.addLast("encoder", new HttpResponseDecoder());
        }
    }

}

如果你需要在 ChannelPipeline 中有一个解码器和编码器，还分别有一个在客户端和服务器简单的编解码器：HttpClientCodec 和 HttpServerCodec

pipeline.addLast("aggegator", new HttpObjectAggregator(512 * 1024));  聚合消息

 WebSocket

WebSocketServerProtocolHandler

处理空闲连接和超时

• IdleStateHandler，当一个通道没有进行读写或运行了一段时间后出发IdleStateEvent
• ReadTimeoutHandler，在指定时间内没有接收到任何数据将抛出ReadTimeoutException
• WriteTimeoutHandler，在指定时间内有写入数据将抛出WriteTimeoutException、

最常用的是IdleStateHandler，下面代码显示了如何使用IdleStateHandler，如果60秒内没有接收数据或发送数据，操作将失败，连接将关闭

public class IdleStateHandlerInitializer extends ChannelInitializer<Channel> {

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new IdleStateHandler(0, 0, 60, TimeUnit.SECONDS));
        pipeline.addLast(new HeartbeatHandler());
    }

    public static final class HeartbeatHandler extends ChannelInboundHandlerAdapter {
        private static final ByteBuf HEARTBEAT_SEQUENCE = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer(
                "HEARTBEAT", CharsetUtil.UTF_8));

        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            if (evt instanceof IdleStateEvent) {
                ctx.writeAndFlush(HEARTBEAT_SEQUENCE.duplicate()).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                super.userEventTriggered(ctx, evt);
            }
        }
    }
}

分隔符协议  解决粘包问题

使用LineBasedFrameDecoder提取"\r\n"分隔帧

/**
 * 处理换行分隔符消息
 *
 */
public class LineBasedHandlerInitializer extends ChannelInitializer<Channel> {

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(new LineBasedFrameDecoder(65 * 1204), new FrameHandler());
    }

    public static final class FrameHandler extends SimpleChannelInboundHandler<ByteBuf> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
            // do something with the frame
        }
    }
}

如果框架的东西除了换行符还有别的分隔符，可以使用DelimiterBasedFrameDecoder，只需要将分隔符传递到构造方法中。如果想实现自己的以分隔符为基础的协议，这些解码器是有用的。

例如，现在有个协议，它只处理命令，这些命令由名称和参数形成，名称和参数由一个空格分隔

public class CmdHandlerInitializer extends ChannelInitializer<Channel> {

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(new CmdDecoder(65 * 1024), new CmdHandler());
    }

    public static final class Cmd {
        private final ByteBuf name;
        private final ByteBuf args;

        public Cmd(ByteBuf name, ByteBuf args) {
            this.name = name;
            this.args = args;
        }

        public ByteBuf getName() {
            return name;
        }

        public ByteBuf getArgs() {
            return args;
        }
    }

    public static final class CmdDecoder extends LineBasedFrameDecoder {

        public CmdDecoder(int maxLength) {
            super(maxLength);
        }

        @Override
        protected Object decode(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
            ByteBuf frame = (ByteBuf) super.decode(ctx, buffer);
            if (frame == null) {
                return null;
            }
            int index = frame.indexOf(frame.readerIndex(), frame.writerIndex(), (byte) ' ');
            return new Cmd(frame.slice(frame.readerIndex(), index), frame.slice(index + 1, frame.writerIndex()));
        }
    }

    public static final class CmdHandler extends SimpleChannelInboundHandler<Cmd> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, Cmd msg) throws Exception {
            // do something with the command
        }
    }

}

一般经常会碰到以长度为基础的协议，对于这种情况Netty有两个不同的解码器可以帮助我们来解码：

• FixedLengthFrameDecoder
• LengthFieldBasedFrameDecoder

ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(65*1024, 0, 8))

读取大文件

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        File file = new File("test.txt");
        FileInputStream fis = new FileInputStream(file);
        FileRegion region = new DefaultFileRegion(fis.getChannel(), 0, file.length());
        Channel channel = ctx.channel();
        channel.writeAndFlush(region).addListener(new ChannelFutureListener() {

            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if(!future.isSuccess()){
                    Throwable cause = future.cause();
                    // do something
                }
            }
        });
    }

public class ChunkedWriteHandlerInitializer extends ChannelInitializer<Channel> {
    private final File file;

    public ChunkedWriteHandlerInitializer(File file) {
        this.file = file;
    }

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(new ChunkedWriteHandler())
            .addLast(new WriteStreamHandler());
    }

    public final class WriteStreamHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            super.channelActive(ctx);
            ctx.writeAndFlush(new ChunkedStream(new FileInputStream(file)));
        }
    }
}

通过JBoss编组序列化

使用ProtoBuf序列化

/**
 * 使用protobuf序列化数据，进行编码解码
 * 注意：使用protobuf需要protobuf-java-2.5.0.jar
 * @author Administrator
 *
 */
public class ProtoBufInitializer extends ChannelInitializer<Channel> {

    private final MessageLite lite;

    public ProtoBufInitializer(MessageLite lite) {
        this.lite = lite;
    }

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(new ProtobufVarint32FrameDecoder())
            .addLast(new ProtobufEncoder())
            .addLast(new ProtobufDecoder(lite))
            .addLast(new ObjectHandler());
    }

    public final class ObjectHandler extends SimpleChannelInboundHandler<Serializable> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, Serializable msg) throws Exception {
            // do something
        }
    }
}

也可以自己实现，参照RPC

Bootstrap   当需要引导客户端或一些无连接协议时

 创建Bootstrap实例使用new关键字，下面是Bootstrap的方法：

• group(...)，设置EventLoopGroup,EventLoopGroup用来处理所有通道的IO事件
• channel(...)，设置通道类型
• channelFactory(...)，使用ChannelFactory来设置通道类型
• localAddress(...)，设置本地地址，也可以通过bind(...)或connect(...)
• option(ChannelOption<T>, T)，设置通道选项，若使用null，则删除上一个设置的ChannelOption
• attr(AttributeKey<T>, T)，设置属性到Channel，若值为null，则指定键的属性被删除
• handler(ChannelHandler)，设置ChannelHandler用于处理请求事件
• clone()，深度复制Bootstrap，Bootstrap的配置相同
• remoteAddress(...)，设置连接地址
• connect(...)，连接远程通道
• bind(...)，创建一个新的Channel并绑

ServerBootstrap  引导服务器

从Channel引导客户端

有时候需要从另一个Channel引导客户端，例如写一个代理或需要从其他系统检索数据。从其他系统获取数据时比较常见的，有很多Netty应用程序必须要和企业现有的系统集成，如Netty程序与内部系统进行身份验证，查询数据库等

可以不用再创建新的引导

public class BootstrapingFromChannel {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                .childHandler(new SimpleChannelInboundHandler<ByteBuf>() {
                    ChannelFuture connectFuture;

                    @Override
                    public void channelActive(ChannelHandlerContext ctx) throws Exception {
                        Bootstrap b = new Bootstrap();
                        b.channel(NioSocketChannel.class).handler(
                                new SimpleChannelInboundHandler<ByteBuf>() {
                                    @Override
                                    protected void channelRead0(ChannelHandlerContext ctx,
                                            ByteBuf msg) throws Exception {
                                        System.out.println("Received data");
                                        msg.clear();
                                    }
                                });
                        b.group(ctx.channel().eventLoop());
                        connectFuture = b.connect(new InetSocketAddress("127.0.0.1", 2048));
                    }

                    @Override
                    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
                            throws Exception {
                        if (connectFuture.isDone()) {
                            // do something with the data
                        }
                    }
                });
        ChannelFuture f = b.bind(2048);
        f.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("Server bound");
                } else {
                    System.err.println("bound fail");
                    future.cause().printStackTrace();
                }
            }
        });
    }
}

服务端和客户端在同一环境下

使用通道选项和属性

使用ChannelOption和属性可以让事情变得很简单，例如Netty WebSocket服务器根据用户自动路由消息，通过使用属性，应用程序能在通道存储用户ID以确定消息应该发送到哪里。应用程序可以通过使用一个通道选项进一步自动化，给定时间内没有收到消息将自动断开连接

    public static void main(String[] args) {
        //创建属性键对象
        final AttributeKey<Integer> id = AttributeKey.valueOf("ID");
        //客户端引导对象
        Bootstrap b = new Bootstrap();
        //设置EventLoop，设置通道类型
        b.group(new NioEventLoopGroup()).channel(NioSocketChannel.class)
        //设置ChannelHandler
            .handler(new SimpleChannelInboundHandler<ByteBuf>() {

                @Override
                public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
                    //通道注册后执行，获取属性值
                    Integer idValue = ctx.channel().attr(id).get();
                    System.out.println(idValue);
                    //do something with the idValue
                }

                @Override
                protected void messageReceived(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
                    System.out.println("Reveived data");
                    msg.clear();
                }
            });
        //设置通道选项，在通道注册后或被创建后设置
        b.option(ChannelOption.SO_KEEPALIVE, true).option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000);
        //设置通道属性
        b.attr(id, 123456);
        ChannelFuture f = b.connect("www.manning.com",80);
        f.syncUninterruptibly();
    }