import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
public static void main(final String... args) {
    File log4jConfigurationFile = new File(
            "src/test/resources/log4j.xml");
    if (log4jConfigurationFile.exists()) {
        DOMConfigurator.configureAndWatch(
                log4jConfigurationFile.getAbsolutePath(), 15);
    }
    try {
        final int port = 9090;

        System.out.println("About to start server on port: " + port);
        HttpProxyServerBootstrap bootstrap = DefaultHttpProxyServer
                .bootstrapFromFile("./littleproxy.properties")
                .withPort(port).withAllowLocalOnly(false);

        bootstrap.withManInTheMiddle(new CertificateSniffingMitmManager());

        System.out.println("About to start...");
        bootstrap.start();

    } catch (Exception e) {
        log.error(e.getMessage(), e);
        System.exit(1);
    }
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
/**
 * Bootstrap a new {@link DefaultHttpProxyServer} using defaults from the
 * given file.
 *
 * @param path
 * @return
 */
public static HttpProxyServerBootstrap bootstrapFromFile(String path) {
    final File propsFile = new File(path);
    Properties props = new Properties();

    if (propsFile.isFile()) {
        InputStream is = null;
        try {
            is = new FileInputStream(propsFile);
            props.load(is);
        } catch (final IOException e) {
            LOG.warn("Could not load props file?", e);
        } finally {
            IOUtils.closeQuietly(is);
        }
    }

    return new DefaultHttpProxyServerBootstrap(props);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap clone() {
    return new DefaultHttpProxyServerBootstrap(serverGroup,
            transportProtocol,
            new InetSocketAddress(requestedAddress.getAddress(),
                    requestedAddress.getPort() == 0 ? 0 : requestedAddress.getPort() + 1),
                sslEngineSource,
                authenticateSslClients,
                proxyAuthenticator,
                chainProxyManager,
                mitmManager,
                filtersSource,
                transparent,
                idleConnectionTimeout,
                activityTrackers,
                connectTimeout,
                serverResolver,
                globalTrafficShapingHandler != null ? globalTrafficShapingHandler.getReadLimit() : 0,
                globalTrafficShapingHandler != null ? globalTrafficShapingHandler.getWriteLimit() : 0,
                localAddress,
                proxyAlias);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
/**
 * Bootstrap a new {@link DefaultHttpProxyServer} using defaults from the
 * given file.
 * 
 * @param path
 * @return
 */
public static HttpProxyServerBootstrap bootstrapFromFile(String path) {
    final File propsFile = new File(path);
    Properties props = new Properties();

    if (propsFile.isFile()) {
        InputStream is = null;
        try {
            is = new FileInputStream(propsFile);
            props.load(is);
        } catch (final IOException e) {
            LOG.warn("Could not load props file?", e);
        } finally {
            IOUtils.closeQuietly(is);
        }
    }

    return new DefaultHttpProxyServerBootstrap(props);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap clone() {
    return new DefaultHttpProxyServerBootstrap(this, transportProtocol,
            new InetSocketAddress(requestedAddress.getAddress(),
                    requestedAddress.getPort() == 0 ? 0 : requestedAddress.getPort() + 1),
                sslEngineSource,
                authenticateSslClients,
                proxyAuthenticator,
                chainProxyManager,
                mitmManager,
                filtersSource,
                transparent,
                idleConnectionTimeout,
                activityTrackers,
                connectTimeout,
                serverResolver,
                globalTrafficShapingHandler != null ? globalTrafficShapingHandler.getReadLimit() : 0,
                globalTrafficShapingHandler != null ? globalTrafficShapingHandler.getWriteLimit() : 0);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
public void start() throws IOException {
    HttpProxyServerBootstrap boot = null;
    if ("client".equals(mode)) {
        boot = DefaultHttpProxyServer.bootstrap()
                .withAddress(new InetSocketAddress("localhost", port))
                .withChainProxyManager(chainedProxyManager())
                .withTransportProtocol(TransportProtocol.TCP);
        if (cache) {
            boot = boot.withFiltersSource(filter);
        }

    } else if ("server".equals(mode)) {
        SslEngineSource sslEngineSource = new KazeSslEngineSource(
                "kserver.jks", "tserver.jks", false, true, "serverkey",
                jkspw);
        boot = DefaultHttpProxyServer.bootstrap()
                .withAddress(new InetSocketAddress("0.0.0.0", port))
                .withTransportProtocol(TransportProtocol.TCP)
                .withSslEngineSource(sslEngineSource)
                .withAuthenticateSslClients(false);
    }
    boot.start();
    System.in.read();
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
/**
 * Bootstrap a new {@link DefaultHttpProxyServer} using defaults from the
 * given file.
 * 
 * @param path
 * @return
 */
public static HttpProxyServerBootstrap bootstrapFromFile(String path) {
    final File propsFile = new File(path);
    Properties props = new Properties();

    if (propsFile.isFile()) {
        InputStream is = null;
        try {
            is = new FileInputStream(propsFile);
            props.load(is);
        } catch (final IOException e) {
        	Log.w(TAG, "Could not load props file? " + e.getMessage());
            //LOG.warn("Could not load props file?", e);
        } finally {
            IOUtils.closeQuietly(is);
        }
    }

    return new DefaultHttpProxyServerBootstrap(props);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withSslEngineSource(
        SslEngineSource sslEngineSource) {
    this.sslEngineSource = sslEngineSource;
    if (this.mitmManager != null) {
        LOG.warn("Enabled encrypted inbound connections with man in the middle. "
                + "These are mutually exclusive - man in the middle will be disabled.");
        this.mitmManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.sslEngineSource != null) {
        LOG.warn("Enabled man in the middle with encrypted inbound connections. "
                + "These are mutually exclusive - encrypted inbound connections will be disabled.");
        this.sslEngineSource = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withUseDnsSec(boolean useDnsSec) {
    if (useDnsSec) {
        this.serverResolver = new DnsSecServerResolver();
    } else {
        this.serverResolver = new DefaultHostResolver();
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withThreadPoolConfiguration(ThreadPoolConfiguration configuration) {
    this.clientToProxyAcceptorThreads = configuration.getAcceptorThreads();
    this.clientToProxyWorkerThreads = configuration.getClientToProxyWorkerThreads();
    this.proxyToServerWorkerThreads = configuration.getProxyToServerWorkerThreads();
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withChainProxyManager(
        ChainedProxyManager chainProxyManager) {
    this.chainProxyManager = chainProxyManager;
    if (this.mitmManager != null) {
        LOG.warn("Enabled proxy chaining with man in the middle.  These are mutually exclusive - man in the middle will be disabled.");
        this.mitmManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.chainProxyManager != null) {
        LOG.warn("Enabled man in the middle along with proxy chaining.  These are mutually exclusive - proxy chaining will be disabled.");
        this.chainProxyManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap clone() {
    return new DefaultHttpProxyServerBootstrap(this, transportProtocol,
            new InetSocketAddress(address.getAddress(),
                    address.getPort() + 1),
            sslEngineSource, authenticateSslClients, proxyAuthenticator,
            chainProxyManager,
            mitmManager, filtersSource, useDnsSec, transparent,
            idleConnectionTimeout, activityTrackers);
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withChainProxyManager(
        ChainedProxyManager chainProxyManager) {
    this.chainProxyManager = chainProxyManager;
    if (this.mitmManager != null) {
        Log.w(TAG, "Enabled proxy chaining with man in the middle.  These are mutually exclusive - man in the middle will be disabled.");
        this.mitmManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.chainProxyManager != null) {
        Log.w(TAG, "Enabled man in the middle along with proxy chaining.  These are mutually exclusive - proxy chaining will be disabled.");
        this.chainProxyManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
/**
 * Runs a proxy server counting requests
 * @param authenticating true if the proxy should require authentication
 * @throws Exception if an error occurred
 */
private void startProxy(boolean authenticating) throws Exception {
    proxyPort = findPort();
    
    HttpProxyServerBootstrap bootstrap = DefaultHttpProxyServer.bootstrap()
            .withPort(proxyPort)
            .withFiltersSource(new HttpFiltersSourceAdapter() {
                public HttpFilters filterRequest(HttpRequest originalRequest,
                        ChannelHandlerContext ctx) {
                   return new HttpFiltersAdapter(originalRequest) {
                      @Override
                      public void proxyToServerRequestSent() {
                          proxyCounter++;
                      }
                   };
                }
            });
    
    if (authenticating) {
        bootstrap = bootstrap.withProxyAuthenticator(new ProxyAuthenticator() {
            @Override
            public boolean authenticate(String userName, String password) {
                return PROXY_USERNAME.equals(userName) &&
                        PROXY_PASSWORD.equals(password);
            }

            @Override
            public String getRealm() {
                return "gradle-download-task";
            }
        });
    }
    
    proxy = bootstrap.start();
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withName(String name) {
    this.name = name;
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withTransportProtocol(
        TransportProtocol transportProtocol) {
    this.transportProtocol = transportProtocol;
    return this;
}
 

import org.littleshoot.proxy.HttpProxyServerBootstrap; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withAddress(InetSocketAddress address) {
    this.requestedAddress = address;
    return this;
}