/**
 * netty 实现反向代理
 * 
 * @since 0.27.0
 * @author 老马啸西风
 */
public class NginxRequestDispatchProxyPass extends AbstractNginxRequestDispatch {

    private static final Log logger = LogFactory.getLog(NginxRequestDispatchProxyPass.class);

    @Override
    public void doDispatch(NginxRequestDispatchContext context) {
        // 原始的请求
        final FullHttpRequest request = context.getRequest();
        final ChannelHandlerContext ctx = context.getCtx();

        // 创建一个新的 FullHttpRequest 转发到目标服务器
        FullHttpRequest forwardedRequest = new DefaultFullHttpRequest(
                request.protocolVersion(), request.method(), request.uri(), request.content().retainedDuplicate());
        forwardedRequest.headers().set(request.headers());

        final NginxLoadBalanceConfig nginxLoadBalanceConfig = context.getBalanceConfig();

        // 创建一个新的 Bootstrap 进行 HTTP 请求
        Bootstrap b = new Bootstrap();
        b.group(ctx.channel().eventLoop())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        //...

                        ch.pipeline().addLast(new SimpleChannelInboundHandler<FullHttpResponse>() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext clientCtx, FullHttpResponse response) throws Exception {
                                // 将目标服务器的响应写回到客户端
                                FullHttpResponse clientResponse = new DefaultFullHttpResponse(
                                        response.protocolVersion(), response.status(), response.content().retainedDuplicate());

                                clientResponse.headers().set(response.headers());

                                ctx.writeAndFlush(clientResponse).addListener(ChannelFutureListener.CLOSE);
                                clientCtx.close();
                            }

                            @Override
                            public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                logger.error("exceptionCaught meet ex", cause);
                                ctx.close();
                            }
                        });
                    }
                });

        // 连接到目标服务器并发送请求
        final IServer server = getActualServer(nginxLoadBalanceConfig);
        b.connect(server.host(), server.port()).addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                future.channel().writeAndFlush(forwardedRequest);
            } else {
                ctx.close();
            }
        });
    }
}

负载均衡

负载均衡策略，可以看我以前的文章：

从零手写实现 nginx-32-load balance 负载均衡算法 java 实现

小结

到这里开始，我们基本实现了反向代理。

当然，其中还有很多细节需要处理。