import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
public BrowserMobHttpFilterChain(BrowserMobProxyServer proxyServer, HttpRequest originalRequest, ChannelHandlerContext ctx) {
    super(originalRequest, ctx);

    this.proxyServer = proxyServer;

    if (proxyServer.getFilterFactories() != null) {
        filters = new ArrayList<>(proxyServer.getFilterFactories().size());

        // instantiate all HttpFilters using the proxy's filter factories
        for (HttpFiltersSource filterFactory : proxyServer.getFilterFactories()) {
            HttpFilters filter = filterFactory.filterRequest(originalRequest, ctx);
            // allow filter factories to avoid adding a filter on a per-request basis by returning a null
            // HttpFilters instance
            if (filter != null) {
                filters.add(filter);
            }
        }
    } else {
        filters = Collections.emptyList();
    }
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private DefaultHttpProxyServer(String name,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filterSource,
        boolean useDnsSec,
        boolean transparent,
        int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this(new ServerGroup(name), transportProtocol, address,
            sslEngineSource, authenticateSslClients, proxyAuthenticator,
            chainProxyManager,
            mitmManager, filterSource, useDnsSec, transparent,
            idleConnectionTimeout, activityTrackers);
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private int getMaximumRequestBufferSize() {
    int maxBufferSize = 0;
    for (HttpFiltersSource source : filterFactories) {
        int requestBufferSize = source.getMaximumRequestBufferSizeInBytes();
        if (requestBufferSize > maxBufferSize) {
            maxBufferSize = requestBufferSize;
        }
    }

    return maxBufferSize;
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private int getMaximumResponseBufferSize() {
    int maxBufferSize = 0;
    for (HttpFiltersSource source : filterFactories) {
        int requestBufferSize = source.getMaximumResponseBufferSizeInBytes();
        if (requestBufferSize > maxBufferSize) {
            maxBufferSize = requestBufferSize;
        }
    }

    return maxBufferSize;
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        ServerGroup serverGroup,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond,
        long  writeThrottleBytesPerSecond,
        InetSocketAddress localAddress,
        String proxyAlias) {
    this.serverGroup = serverGroup;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.mitmManager = mitmManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
    this.localAddress = localAddress;
    this.proxyAlias = proxyAlias;
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond, long  writeThrottleBytesPerSecond) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource, boolean useDnsSec,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.address = address;
    this.port = address.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.useDnsSec = useDnsSec;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
@Override
public void addFirstHttpFilterFactory(HttpFiltersSource filterFactory) {
    filterFactories.add(0, filterFactory);
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
@Override
public void addLastHttpFilterFactory(HttpFiltersSource filterFactory) {
    filterFactories.add(filterFactory);
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
public void addHttpFilterFactory(HttpFiltersSource filterFactory) {
    filterFactories.add(filterFactory);
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
public List<HttpFiltersSource> getFilterFactories() {
    return filterFactories;
}
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
public HttpFiltersSource getFiltersSource() {
    return filtersSource;
}
 

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

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
/**
 * Adds a new filter factory (request/response interceptor) to the beginning of the HttpFilters chain.
 * <p/>
 * <b>Usage note:</b> The actual filter (interceptor) instance is created on every request by implementing the
 * {@link HttpFiltersSource#filterRequest(io.netty.handler.codec.http.HttpRequest, io.netty.channel.ChannelHandlerContext)} method and returning an
 * {@link org.littleshoot.proxy.HttpFilters} instance (typically, a subclass of {@link org.littleshoot.proxy.HttpFiltersAdapter}).
 * To disable or bypass a filter on a per-request basis, the filterRequest() method may return null.
 *
 * @param filterFactory factory to generate HttpFilters
 */
void addFirstHttpFilterFactory(HttpFiltersSource filterFactory);
 

import org.littleshoot.proxy.HttpFiltersSource; //导入依赖的package包/类
/**
 * Adds a new filter factory (request/response interceptor) to the end of the HttpFilters chain.
 * <p/>
 * <b>Usage note:</b> The actual filter (interceptor) instance is created on every request by implementing the
 * {@link HttpFiltersSource#filterRequest(io.netty.handler.codec.http.HttpRequest, io.netty.channel.ChannelHandlerContext)} method and returning an
 * {@link org.littleshoot.proxy.HttpFilters} instance (typically, a subclass of {@link org.littleshoot.proxy.HttpFiltersAdapter}).
 * To disable or bypass a filter on a per-request basis, the filterRequest() method may return null.
 *
 *  @param filterFactory factory to generate HttpFilters
 */
void addLastHttpFilterFactory(HttpFiltersSource filterFactory);