java netty开发一个http/https代理

下面是一个简单的 Java Netty 实现的 HTTP/HTTPS 代理服务代码示例：

import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.DefaultHttpRequest;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
import io.netty.util.CharsetUtil;

import javax.net.ssl.SSLEngine;
import java.net.InetSocketAddress;
import java.util.HashMap;
import java.util.Map;

public class HttpsProxyServer {

    private final int port;

    public HttpsProxyServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new HttpServerCodec());
                            ch.pipeline().addLast(new HttpsProxyServerHandler());
                        }
                    })
                    .childOption(ChannelOption.AUTO_READ, false)
                    .bind().sync().channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Usage: " + HttpsProxyServer.class.getSimpleName() + " <port>");
            return;
        }
        int port = Integer.parseInt(args[0]);
        new HttpsProxyServer(port).start();
    }

    private static final class HttpsProxyServerHandler extends SimpleChannelInboundHandler<HttpObject> {

        private Channel clientChannel;
        private Channel serverChannel;
        private SSLEngine sslEngine;
        private boolean isHttps;
        private final Map<String, String> headers = new HashMap<>();

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            clientChannel = ctx.channel();
        }

        @Override
        public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
            if (msg instanceof DefaultHttpRequest) {
                DefaultHttpRequest request = (DefaultHttpRequest) msg;
                String requestUri = request.getUri();
                isHttps = requestUri.startsWith("https://");
                String[] hostParts = HttpHeaders.getHost(request).split(":");
                String host = hostParts[0];
                int port = isHttps ? 443 : (hostParts.length > 1 ? Integer.parseInt(hostParts[1]) : 80);
                Bootstrap b = new Bootstrap();
                b.group(clientChannel.eventLoop())
                        .channel(NioSocketChannel.class)
                        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            public void initChannel(SocketChannel ch) throws Exception {
                                if (isHttps) {
                                    sslEngine = SslContextBuilder.forClient()
                                            .trustManager(InsecureTrustManagerFactory.INSTANCE)
                                            .build().newEngine(ch.alloc(), host, port);
                                    ch.pipeline().addLast(new SslHandler(sslEngine));
                                }
                                ch.pipeline().addLast(new HttpClientCodec());
                                ch.pipeline().addLast(new HttpsProxyServerHandler());
                            }
                        })
                        .connect(host, port)
                        .addListener((ChannelFuture future) -> {
                            if (future.isSuccess()) {
                                serverChannel = future.channel();
                            } else {
                                clientChannel.close();
                            }
                        });
                headers.clear();
                for (Map.Entry<String, String> entry : request.headers()) {
                    headers.put(entry.getKey(), entry.getValue());
                }
                headers.remove(HttpHeaders.Names.HOST);
                b.channel(NioSocketChannel.class)
                        .connect(host, port)
                        .addListener((ChannelFuture future) -> {
                            if (future.isSuccess()) {
                                serverChannel = future.channel();
                                serverChannel.writeAndFlush(request.retain());
                                clientChannel.read();
                            } else {
                                clientChannel.close();
                            }
                        });
            } else if (msg instanceof HttpResponse) {
                HttpResponse response = (HttpResponse) msg;
                response.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING);
                response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
                clientChannel.writeAndFlush(response.retain());
            } else if (msg instanceof HttpContent) {
                HttpContent content = (HttpContent) msg;
                clientChannel.writeAndFlush(content.retain());
                if (content instanceof LastHttpContent) {
                    if (isHttps) {
                        sslEngine.closeOutbound();
                    }
                    clientChannel.flush();
                    clientChannel.close();
                    serverChannel.close();
                }
            }
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            if (clientChannel.isActive()) {
                clientChannel.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_GATEWAY,
                        Unpooled.copiedBuffer("Failure: " + cause.getMessage(), CharsetUtil.UTF_8)))
                        .addListener(ChannelFutureListener.CLOSE);
            }
        }
    }
}

这是一个简单的 HTTP/HTTPS 代理服务，可以接收来自客户端的请求，并将其转发到目标服务器。如果请求是 HTTPS 请求，它还会与目标服务器建立安全连接。

在这个示例中，我们使用了 Netty 的 HTTP/HTTPS 编解码器和 SSL 处理程序来处理请求和响应，并将它们转发到目标服务器。在建立与目标服务器的连接时，我们还使用了 Netty 的 Bootstrap 类来创建客户端通道。

当客户端发送请求时，我们从请求中提取目标主机和端口，并使用 Bootstrap 类创建一个新的客户端通道，然后将请求发送到目标服务器。在接收到来自目标服务器的响应时，我们将响应转发给客户端。

如果请求是 HTTPS 请求，我们还需要使用 SSL 处理程序来建立与目标服务器的安全连接。我们使用 Netty 的 SslContextBuilder 类创建一个 SSL 引擎，并将其添加到客户端通道的管道中。在建立与目标服务器的连接时，我们还需要使用 SslHandler 将 SSL 引擎添加到客户端通道的管道中，以便进行 SSL 握手。