聊聊AsyncHttpClient的默认配置

        <dependency>
            <groupId>org.asynchttpclient</groupId>
            <artifactId>async-http-client</artifactId>
            <version>2.2.0</version>
        </dependency>

public interface AsyncHttpClientConfig {

  /**
   * @return the version of AHC
   */
  String getAhcVersion();

  /**
   * Return the name of {@link AsyncHttpClient}, which is used for thread naming and debugging.
   *
   * @return the name.
   */
  String getThreadPoolName();

  /**
   * Return the maximum number of connections an {@link AsyncHttpClient} can handle.
   *
   * @return the maximum number of connections an {@link AsyncHttpClient} can handle.
   */
  int getMaxConnections();

  /**
   * Return the maximum number of connections per hosts an {@link AsyncHttpClient} can handle.
   *
   * @return the maximum number of connections per host an {@link AsyncHttpClient} can handle.
   */
  int getMaxConnectionsPerHost();

  /**
   * Return the maximum time in millisecond an {@link AsyncHttpClient} can wait when connecting to a remote host
   *
   * @return the maximum time in millisecond an {@link AsyncHttpClient} can wait when connecting to a remote host
   */
  int getConnectTimeout();

  /**
   * Return the maximum time in millisecond an {@link AsyncHttpClient} can stay idle.
   *
   * @return the maximum time in millisecond an {@link AsyncHttpClient} can stay idle.
   */
  int getReadTimeout();

  /**
   * Return the maximum time in millisecond an {@link AsyncHttpClient} will keep connection in pool.
   *
   * @return the maximum time in millisecond an {@link AsyncHttpClient} will keep connection in pool.
   */
  int getPooledConnectionIdleTimeout();

  /**
   * @return the period in millis to clean the pool of dead and idle connections.
   */
  int getConnectionPoolCleanerPeriod();

  /**
   * Return the maximum time in millisecond an {@link AsyncHttpClient} waits until the response is completed.
   *
   * @return the maximum time in millisecond an {@link AsyncHttpClient} waits until the response is completed.
   */
  int getRequestTimeout();

  /**
   * Is HTTP redirect enabled
   *
   * @return true if enabled.
   */
  boolean isFollowRedirect();

  /**
   * Get the maximum number of HTTP redirect
   *
   * @return the maximum number of HTTP redirect
   */
  int getMaxRedirects();

  /**
   * Is the {@link ChannelPool} support enabled.
   *
   * @return true if keep-alive is enabled
   */
  boolean isKeepAlive();

  /**
   * Return the USER_AGENT header value
   *
   * @return the USER_AGENT header value
   */
  String getUserAgent();

  /**
   * Is HTTP compression enforced.
   *
   * @return true if compression is enforced
   */
  boolean isCompressionEnforced();

  /**
   * Return the {@link java.util.concurrent.ThreadFactory} an {@link AsyncHttpClient} use for handling asynchronous response.
   *
   * @return the {@link java.util.concurrent.ThreadFactory} an {@link AsyncHttpClient} use for handling asynchronous response. If no {@link ThreadFactory} has been explicitly
   * provided, this method will return <code>null</code>
   */
  ThreadFactory getThreadFactory();

  /**
   * An instance of {@link ProxyServer} used by an {@link AsyncHttpClient}
   *
   * @return instance of {@link ProxyServer}
   */
  ProxyServerSelector getProxyServerSelector();

  /**
   * Return an instance of {@link SslContext} used for SSL connection.
   *
   * @return an instance of {@link SslContext} used for SSL connection.
   */
  SslContext getSslContext();

  /**
   * Return the current {@link Realm}
   *
   * @return the current {@link Realm}
   */
  Realm getRealm();

  /**
   * Return the list of {@link RequestFilter}
   *
   * @return Unmodifiable list of {@link ResponseFilter}
   */
  List<RequestFilter> getRequestFilters();

  /**
   * Return the list of {@link ResponseFilter}
   *
   * @return Unmodifiable list of {@link ResponseFilter}
   */
  List<ResponseFilter> getResponseFilters();

  /**
   * Return the list of {@link java.io.IOException}
   *
   * @return Unmodifiable list of {@link java.io.IOException}
   */
  List<IOExceptionFilter> getIoExceptionFilters();

  /**
   * Return cookie store that is used to store and retrieve cookies
   *
   * @return {@link CookieStore} object
   */
  CookieStore getCookieStore();

  /**
   * Return the number of time the library will retry when an {@link java.io.IOException} is throw by the remote server
   *
   * @return the number of time the library will retry when an {@link java.io.IOException} is throw by the remote server
   */
  int getMaxRequestRetry();

  /**
   * @return the disableUrlEncodingForBoundRequests
   */
  boolean isDisableUrlEncodingForBoundRequests();

  /**
   * @return true if AHC is to use a LAX cookie encoder, eg accept illegal chars in cookie value
   */
  boolean isUseLaxCookieEncoder();

  /**
   * In the case of a POST/Redirect/Get scenario where the server uses a 302 for the redirect, should AHC respond to the redirect with a GET or whatever the original method was.
   * Unless configured otherwise, for a 302, AHC, will use a GET for this case.
   *
   * @return <code>true</code> if strict 302 handling is to be used, otherwise <code>false</code>.
   */
  boolean isStrict302Handling();

  /**
   * @return the maximum time in millisecond an {@link AsyncHttpClient} will keep connection in the pool, or -1 to keep connection while possible.
   */
  int getConnectionTtl();

  boolean isUseOpenSsl();

  boolean isUseInsecureTrustManager();

  /**
   * @return true to disable all HTTPS behaviors AT ONCE, such as hostname verification and SNI
   */
  boolean isDisableHttpsEndpointIdentificationAlgorithm();

  /**
   * @return the array of enabled protocols
   */
  String[] getEnabledProtocols();

  /**
   * @return the array of enabled cipher suites
   */
  String[] getEnabledCipherSuites();

  /**
   * @return the size of the SSL session cache, 0 means using the default value
   */
  int getSslSessionCacheSize();

  /**
   * @return the SSL session timeout in seconds, 0 means using the default value
   */
  int getSslSessionTimeout();

  //......
}  

public class DefaultAsyncHttpClientConfig implements AsyncHttpClientConfig {

  //......

  public static class Builder {
  	// timeouts

  	// keep-alive

  	// ssl

  	// cookie store

  	// tuning

  	// internals
  }
}

	// org.asynchttpclient.connectTimeout=5000
    private int connectTimeout = defaultConnectTimeout();

    // org.asynchttpclient.requestTimeout=60000
    private int requestTimeout = defaultRequestTimeout();

    // org.asynchttpclient.readTimeout=60000
    private int readTimeout = defaultReadTimeout();

    // org.asynchttpclient.shutdownQuietPeriod=2000
    private int shutdownQuietPeriod = defaultShutdownQuietPeriod();

    // org.asynchttpclient.shutdownTimeout=15000
    private int shutdownTimeout = defaultShutdownTimeout();

	// org.asynchttpclient.keepAlive=true
    private boolean keepAlive = defaultKeepAlive();

    // org.asynchttpclient.pooledConnectionIdleTimeout=60000
    private int pooledConnectionIdleTimeout = defaultPooledConnectionIdleTimeout();

    // org.asynchttpclient.connectionPoolCleanerPeriod=1000
    private int connectionPoolCleanerPeriod = defaultConnectionPoolCleanerPeriod();

    // org.asynchttpclient.connectionTtl=-1
    private int connectionTtl = defaultConnectionTtl();

    // org.asynchttpclient.maxConnections=-1
    private int maxConnections = defaultMaxConnections();

    // org.asynchttpclient.maxConnectionsPerHost=-1
    private int maxConnectionsPerHost = defaultMaxConnectionsPerHost();

    private ChannelPool channelPool;

    private KeepAliveStrategy keepAliveStrategy = new DefaultKeepAliveStrategy();

	// org.asynchttpclient.tcpNoDelay=true
    private boolean tcpNoDelay = defaultTcpNoDelay();

    // org.asynchttpclient.soReuseAddress=false
    private boolean soReuseAddress = defaultSoReuseAddress();

    // org.asynchttpclient.soLinger=-1
    private int soLinger = defaultSoLinger();

    // org.asynchttpclient.soSndBuf=-1
    private int soSndBuf = defaultSoSndBuf();

    // org.asynchttpclient.soRcvBuf=-1
    private int soRcvBuf = defaultSoRcvBuf();

	// org.asynchttpclient.threadPoolName=AsyncHttpClient
    private String threadPoolName = defaultThreadPoolName();

    // org.asynchttpclient.httpClientCodecMaxInitialLineLength=4096
    private int httpClientCodecMaxInitialLineLength = defaultHttpClientCodecMaxInitialLineLength();

    // org.asynchttpclient.httpClientCodecMaxHeaderSize=8192
    private int httpClientCodecMaxHeaderSize = defaultHttpClientCodecMaxHeaderSize();

    // org.asynchttpclient.httpClientCodecMaxChunkSize=8192
    private int httpClientCodecMaxChunkSize = defaultHttpClientCodecMaxChunkSize();

    // org.asynchttpclient.httpClientCodecInitialBufferSize=128
    private int httpClientCodecInitialBufferSize = defaultHttpClientCodecInitialBufferSize();

    // org.asynchttpclient.chunkedFileChunkSize=8192
    private int chunkedFileChunkSize = defaultChunkedFileChunkSize();

    // org.asynchttpclient.useNativeTransport=false
    private boolean useNativeTransport = defaultUseNativeTransport();
    private ByteBufAllocator allocator;
    private Map<ChannelOption<Object>, Object> channelOptions = new HashMap<>();
    private EventLoopGroup eventLoopGroup;
    private Timer nettyTimer;
    private ThreadFactory threadFactory;
    private Consumer<Channel> httpAdditionalChannelInitializer;
    private Consumer<Channel> wsAdditionalChannelInitializer;
    private ResponseBodyPartFactory responseBodyPartFactory = ResponseBodyPartFactory.EAGER;

    // org.asynchttpclient.ioThreadsCount=0
    private int ioThreadsCount = defaultIoThreadsCount();