简介

爱因斯坦说过: 所有的平凡，都产生于简略的细节中。netty 为咱们提供了如此弱小的 eventloop、channel 通过对这些简略货色的无效利用，能够失去十分弱小的应用程序，比方明天要讲的代理。

代理和反向代理

置信只有是程序员应该都听过 nginx 服务器了，这个超级优良 nginx 一个很重要的性能就是做反向代理。那么有小伙伴要问了，有反向代理必定就有正向代理，那么他们两个有什么区别呢？

先讲一下正向代理，举个例子，最近流量明星备受打击，尽管被打压，然而明星就是明星，个别人是见不到的，如果有人须要跟明星对话的话，须要首先通过明星的经纪人，有经纪人将话转达给明星。这个经纪人就是正向代理。咱们通过正向代理来拜访要拜访的对象。

那么什么是反向代理呢？比方当初呈现了很多人工智能，如果咱们跟智能机器人 A 对话，而后 A 把咱们之间的对话转给了前面的藏着的人，这个人用他的智慧，答复了咱们的对话，交由智能机器人 A 输入，最终实现了人工智能。这个过程就叫做反向代理。

netty 实现代理的原理

那么在 netty 中怎么实现这个代理服务器呢？

首选咱们首先代理服务器是一个服务器，所以咱们须要在 netty 中应用 ServerBootstrap 创立一个服务器：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new SimpleDumpProxyInitializer(REMOTE_HOST, REMOTE_PORT))
             .childOption(ChannelOption.AUTO_READ, false)
             .bind(LOCAL_PORT).sync().channel().closeFuture().sync();

在这个 local 服务器中，咱们传入 ProxyInitializer。在这个 handler 初始化器中，咱们传入自定义的 handler：

    public void initChannel(SocketChannel ch) {ch.pipeline().addLast(new LoggingHandler(LogLevel.INFO),
                new SimpleDumpProxyInboundHandler(remoteHost, remotePort));
    }

在自定义的 handler 中，咱们应用 Bootstrap 创立一个 client，用来连贯近程要代理的服务器，咱们将这个 client 端的创立放在 channelActive 办法中：

// 开启 outbound 连贯
        Bootstrap b = new Bootstrap();
        b.group(inboundChannel.eventLoop())
         .channel(ctx.channel().getClass())
         .handler(new SimpleDumpProxyOutboundHandler(inboundChannel))
         .option(ChannelOption.AUTO_READ, false);
        ChannelFuture f = b.connect(remoteHost, remotePort);

而后在 client 建设好连贯之后，就能够从 inboundChannel 中读取数据了：

outboundChannel = f.channel();
        f.addListener(future -> {if (future.isSuccess()) {
                // 连贯建设结束，读取 inbound 数据
                inboundChannel.read();} else {
                // 敞开 inbound channel
                inboundChannel.close();}
        });

因为是代理服务，所以须要将 inboundChannel 读取的数据，转发给 outboundChannel，所以在 channelRead 中咱们须要这样写：

    public void channelRead(final ChannelHandlerContext ctx, Object msg) {
        // 将 inboundChannel 中的音讯读取，并写入到 outboundChannel
        if (outboundChannel.isActive()) {outboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {if (future.isSuccess()) {
                    // flush 胜利，读取下一个音讯
                    ctx.channel().read();
                } else {future.channel().close();}
            });
        }
    }

当 outboundChannel 写胜利之后，再持续 inboundChannel 的读取工作。

同样对于 client 的 outboundChannel 来说，也有一个 handler，在这个 handler 中，咱们须要将 outboundChannel 读取到的数据反写会 inboundChannel 中：

    public void channelRead(final ChannelHandlerContext ctx, Object msg) {
        // 将 outboundChannel 中的音讯读取，并写入到 inboundChannel 中
        inboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {if (future.isSuccess()) {ctx.channel().read();} else {future.channel().close();}
        });
    }

当 inboundChannel 写胜利之后，再持续 outboundChannel 的读取工作。

如此一个简略的代理服务器就实现了。

实战

如果咱们将本地的 8000 端口，代理到 www.163.com 的 80 端口，会产生什么状况呢？运行咱们的程序，拜访 http://localhost:8000, 咱们会看到上面的页面：

为什么没有如咱们设想的那样展现失常的页面呢？那是因为咱们代理过来之后的域名是 localhost，而不是失常的 www.163.com, 所以服务器端不意识咱们的申请，从而报错。

总结

本文的代理服务器之间简略的转发申请，并不可能解决上述的场景，那么该怎么解决下面的问题呢？敬请期待我的后续文章！

本文的例子能够参考：learn-netty4

本文已收录于 http://www.flydean.com/35-netty-simple-proxy/

最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！

欢送关注我的公众号:「程序那些事」, 懂技术，更懂你！