import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
/**
 * Return a new eventual {@link ProxyHandler}
 *
 * @return a new eventual {@link ProxyHandler}
 */
public final ProxyHandler newProxyHandler() {
	InetSocketAddress proxyAddr = this.address.get();
	String username = this.username;
	String password = Objects.nonNull(username) && Objects.nonNull(this.password) ?
			this.password.apply(username) : null;

	switch (this.type) {
		case HTTP:
			return Objects.nonNull(username) && Objects.nonNull(password) ?
					new HttpProxyHandler(proxyAddr, username, password) :
					new HttpProxyHandler(proxyAddr);
		case SOCKS4:
			return Objects.nonNull(username) ? new Socks4ProxyHandler(proxyAddr, username) :
					new Socks4ProxyHandler(proxyAddr);
		case SOCKS5:
			return Objects.nonNull(username) && Objects.nonNull(password) ?
					new Socks5ProxyHandler(proxyAddr, username, password) :
					new Socks5ProxyHandler(proxyAddr);
	}
	throw new IllegalArgumentException("Proxy type unsupported : " + this.type);
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
protected Bootstrap initBootStrap(Promise<Channel> promise, EventLoopGroup eventLoopGroup) {
    return new Bootstrap()
            .group(eventLoopGroup)
            .channel(NioSocketChannel.class)
            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, NettySettings.CONNECT_TIMEOUT)
            .option(ChannelOption.SO_KEEPALIVE, true)
            .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ProxyHandler proxyHandler = proxyHandlerSupplier.get();
                    if (proxyHandler != null) {
                        ch.pipeline().addLast(proxyHandler);
                    }
                    ch.pipeline().addLast(new ChannelActiveAwareHandler(promise));
                }
            });
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public ProxyHandler newProxyHandler() {
    switch (proxySetting.getType()) {
        case ProxySetting.TYPE_HTTP:
            if (proxySetting.getUser().isEmpty()) {
                return new HttpProxyHandler(address);
            } else {
                return new HttpProxyHandler(address, proxySetting.getUser(), proxySetting.getPassword());
            }

        case ProxySetting.TYPE_SOCKS5:
            if (proxySetting.getUser().isEmpty()) {
                return new Socks5ProxyHandler(address);
            } else {
                return new Socks5ProxyHandler(address, proxySetting.getUser(), proxySetting.getPassword());
            }
        case ProxySetting.TYPE_SOCKS4:
            if (proxySetting.getUser().isEmpty()) {
                return new Socks4ProxyHandler(address);
            } else {
                return new Socks4ProxyHandler(address, proxySetting.getUser());
            }
        default:
            throw new RuntimeException("unknown proxy type: " + proxySetting.getType());
    }
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
static void addProxyHandler(ClientOptions clientOptions, ChannelPipeline pipeline, SocketAddress providedAddress) {
	ProxyHandler proxy = clientOptions.useProxy(providedAddress) ? clientOptions.getProxyOptions().newProxyHandler() : null;
	if (proxy != null) {
		pipeline.addFirst(NettyPipeline.ProxyHandler, proxy);
		if(log.isDebugEnabled()){
			pipeline.addFirst(new LoggingHandler("reactor.ipc.netty.proxy"));
		}
	}
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public HttpTunnelProxyMatcher(MessageListener messageListener,
                              ServerSSLContextManager sslContextManager,
                              Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.sslContextManager = sslContextManager;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
@Override
public ProxyHandler get() {
    if (!proxySetting.isUse()) {
        return null;
    }
    ProxyHandler proxyHandler = newProxyHandler();
    proxyHandler.setConnectTimeoutMillis(NettySettings.CONNECT_TIMEOUT);
    return proxyHandler;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
private void handleProxyData(Channel channel, Object msg, boolean isHttp)
    throws Exception {
  if (cf == null) {
    if (isHttp && !(msg instanceof HttpRequest)) {  //connection异常 还有HttpContent进来，不转发
      return;
    }
    ProxyHandler proxyHandler = ProxyHandleFactory.build(proxyConfig);
    /*
      添加SSL client hello的Server Name Indication extension(SNI扩展)
      有些服务器对于client hello不带SNI扩展时会直接返回Received fatal alert: handshake_failure(握手错误)
      例如：https://cdn.mdn.mozilla.net/static/img/favicon32.7f3da72dcea1.png
     */
    RequestProto requestProto = new RequestProto(host, port, isSsl);
    ChannelInitializer channelInitializer =
        isHttp ? new HttpProxyInitializer(channel, requestProto, proxyHandler)
            : new TunnelProxyInitializer(channel, proxyHandler);
    Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(serverConfig.getLoopGroup()) // 注册线程池
        .channel(NioSocketChannel.class) // 使用NioSocketChannel来作为连接用的channel类
        .handler(channelInitializer);
    if (proxyConfig != null) {
      //代理服务器解析DNS和连接
      bootstrap.resolver(NoopAddressResolverGroup.INSTANCE);
    }
    requestList = new LinkedList();
    cf = bootstrap.connect(host, port);
    cf.addListener((ChannelFutureListener) future -> {
      if (future.isSuccess()) {
        future.channel().writeAndFlush(msg);
        synchronized (requestList) {
          requestList.forEach((obj) -> future.channel().write(obj));
          requestList.clear();
          isConnect = true;
        }
      } else {
        future.channel().close();
        channel.close();
      }
    });
  } else {
    synchronized (requestList) {
      if (isConnect) {
        cf.channel().writeAndFlush(msg);
      } else {
        requestList.add(msg);
      }
    }
  }
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public HttpProxyInitializer(Channel clientChannel, RequestProto requestProto,
    ProxyHandler proxyHandler) {
  this.clientChannel = clientChannel;
  this.requestProto = requestProto;
  this.proxyHandler = proxyHandler;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public TunnelProxyInitializer(Channel clientChannel,
    ProxyHandler proxyHandler) {
  this.clientChannel = clientChannel;
  this.proxyHandler = proxyHandler;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
@Override
ProxyHandler getProxyHandler(ProxyProperties proxyProperties) {
	return new Socks5ProxyHandler(
			new InetSocketAddress(proxyProperties.getProxyAddress(),
					proxyProperties.getProxyPort()));
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public Socks5ProxyMatcher(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                          Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.sslContextManager = sslContextManager;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public Socks4ProxyMatcher(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                          Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.sslContextManager = sslContextManager;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public HttpProxyMatcher(MessageListener messageListener, Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public TunnelProxyHandler(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                          Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.sslContextManager = sslContextManager;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public Socks4ProxyHandler(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                          Supplier<ProxyHandler> proxyHandlerSupplier) {
    super(messageListener, sslContextManager, proxyHandlerSupplier);
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public Socks5ProxyHandler(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                          Supplier<ProxyHandler> proxyHandlerSupplier) {
    super(messageListener, sslContextManager, proxyHandlerSupplier);
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public HttpTunnelProxyHandler(MessageListener messageListener, ServerSSLContextManager sslContextManager,
                              Supplier<ProxyHandler> proxyHandlerSupplier) {
    super(messageListener, sslContextManager, proxyHandlerSupplier);
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public HttpProxyHandler(MessageListener messageListener, Supplier<ProxyHandler> proxyHandlerSupplier) {
    this.messageListener = messageListener;
    this.proxyHandlerSupplier = proxyHandlerSupplier;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
public BufferUntilProxyTunnelledHandler(
    ProxyHandler proxyHandler, ProtocolNegotiator.Handler handler) {
  super(proxyHandler, handler);
  this.originalHandler = handler;
}
 

import io.netty.handler.proxy.ProxyHandler; //导入依赖的package包/类
@Override
public ProxyHandler createProxyHandler() {
    return new Socks4ProxyHandler(this.proxyAddress, this.username);
}