import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
private ProxyToServerConnection(
        DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        ChainedProxy chainedProxy,
        Queue<ChainedProxy> availableChainedProxies,
        HttpFilters initialFilters,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    super(DISCONNECTED, proxyServer, true);
    this.clientConnection = clientConnection;
    this.serverHostAndPort = serverHostAndPort;
    this.chainedProxy = chainedProxy;
    this.availableChainedProxies = availableChainedProxies;
    this.trafficHandler = globalTrafficShapingHandler;
    this.currentFilters = initialFilters;

    // Report connection status to HttpFilters
    currentFilters.proxyToServerConnectionQueued();

    setupConnectionParameters();
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
private ProxyToServerConnection(
        DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        ChainedProxy chainedProxy,
        Queue<ChainedProxy> availableChainedProxies,
        HttpFilters initialFilters,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    super(DISCONNECTED, proxyServer, true);
    this.clientConnection = clientConnection;
    this.serverHostAndPort = serverHostAndPort;
    this.chainedProxy = chainedProxy;
    this.availableChainedProxies = availableChainedProxies;
    this.trafficHandler = globalTrafficShapingHandler;
    this.currentFilters = initialFilters;

    // Report connection status to HttpFilters
    this.currentFilters.proxyToServerConnectionQueued();

    setupConnectionParameters();
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
/**
 * Create a new ProxyToServerConnection.
 * 
 * @param proxyServer
 * @param clientConnection
 * @param serverHostAndPort
 * @param initialHttpRequest
 * @return
 * @throws UnknownHostException
 */
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        HttpRequest initialHttpRequest)
        throws UnknownHostException {
    Queue<ChainedProxy> chainedProxies = new ConcurrentLinkedQueue<ChainedProxy>();
    ChainedProxyManager chainedProxyManager = proxyServer
            .getChainProxyManager();
    if (chainedProxyManager != null) {
        chainedProxyManager.lookupChainedProxies(initialHttpRequest,
                chainedProxies);
    }
    return new ProxyToServerConnection(proxyServer, clientConnection,
            serverHostAndPort, chainedProxies.poll(), chainedProxies);
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
/**
 * Create a new ProxyToServerConnection.
 * 
 * @param proxyServer
 * @param clientConnection
 * @param serverHostAndPort
 * @param initialFilters
 * @param initialHttpRequest
 * @return
 * @throws UnknownHostException
 */
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        HttpFilters initialFilters,
        HttpRequest initialHttpRequest,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    Queue<ChainedProxy> chainedProxies = new ConcurrentLinkedQueue<ChainedProxy>();
    ChainedProxyManager chainedProxyManager = proxyServer
            .getChainProxyManager();
    if (chainedProxyManager != null) {
        chainedProxyManager.lookupChainedProxies(initialHttpRequest,
                chainedProxies);
        if (chainedProxies.size() == 0) {
            // ChainedProxyManager returned no proxies, can't connect
            return null;
        }
    }
    return new ProxyToServerConnection(proxyServer,
            clientConnection,
            serverHostAndPort,
            chainedProxies.poll(),
            chainedProxies,
            initialFilters,
            globalTrafficShapingHandler);
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
private void initProxyServer() throws Exception
{
   org.littleshoot.proxy.ProxyAuthenticator proxyAuthenticator = new org.littleshoot.proxy.ProxyAuthenticator()
   {
      @Override
      public boolean authenticate(String user, String pwd)
      {
         return (PROXY_USER.equals(user) && PROXY_PWD.equals(pwd));
      }
   };
   InetSocketAddress address = new InetSocketAddress(getServerHost(), ++proxyPort);
   ChainedProxyManager chainProxyManager = new ChainedProxyManager()
   {
      @Override
      public void lookupChainedProxies(HttpRequest httpRequest, Queue<ChainedProxy> chainedProxies)
      {
         chainedProxies.add(new ChainedProxyAdapter()
         {
            @Override
            public InetSocketAddress getChainedProxyAddress()
            {
               return new InetSocketAddress(getServerHost(), getServerPort());
            }

         });
      }
   };
   proxyServer = org.littleshoot.proxy.impl.DefaultHttpProxyServer
                         .bootstrap()
                         .withChainProxyManager(chainProxyManager)
                         .withAddress(address)
                         .withProxyAuthenticator(proxyAuthenticator)
                         .start();
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
protected ChainedProxyManager chainedProxyManager() {
    return new ChainedProxyManager() {
        @Override
        public void lookupChainedProxies(HttpRequest httpRequest,
                Queue<ChainedProxy> chainedProxies) {
            chainedProxies.add(newChainedProxy());
        }
    };
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
protected ChainedProxy newChainedProxy() {
    return new ChainedProxyAdapter() {
        @Override
        public TransportProtocol getTransportProtocol() {
            return TransportProtocol.TCP;
        }

        @Override
        public boolean requiresEncryption() {
            return true;
        }

        @Override
        public SSLEngine newSslEngine() {
            SslEngineSource sslEngineSource = new KazeSslEngineSource(
                    "kclient.jks", "tclient.jks", false, true, "serverkey",
                    jkspw);
            return sslEngineSource.newSslEngine();
        }

        @Override
        public InetSocketAddress getChainedProxyAddress() {
            try {
                return new InetSocketAddress(
                        InetAddress.getByName(serverIp), serverPort);
            } catch (UnknownHostException uhe) {
                throw new RuntimeException("Unable to resolve " + serverIp);
            }
        }
    };
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
private ProxyToServerConnection(
        DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        ChainedProxy chainedProxy,
        Queue<ChainedProxy> availableChainedProxies)
        throws UnknownHostException {
    super(DISCONNECTED, proxyServer, true);
    this.clientConnection = clientConnection;
    this.serverHostAndPort = serverHostAndPort;
    this.chainedProxy = chainedProxy;
    this.availableChainedProxies = availableChainedProxies;
    setupConnectionParameters();
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
@Override
public void lookupChainedProxies(HttpRequest httpRequest, Queue<ChainedProxy> chainedProxies) {
   ProxyAdapter proxy = new ProxyAdapter(proxyHost, proxyPort);
   chainedProxies.add(proxy);
}
 

import org.littleshoot.proxy.ChainedProxy; //导入依赖的package包/类
public ChainedProxy getChainedProxy() {
    return chainedProxy;
}