下面列出了怎么用org.apache.http.conn.DnsResolver的API类实例代码及写法，或者点击链接到github查看源代码。
@Test
public void testSupplierFactory() throws Exception {
final DnsResolver resolver = mock(DnsResolver.class);
when(resolver.resolve("example.com")).thenReturn(IPS_1);
when(resolver.resolve("example.net")).thenReturn(IPS_2);
final Supplier<List<URI>> uriSupplier = Suppliers.ofInstance(uris);
final Supplier<List<Endpoint>> endpointSupplier = Endpoints.of(uriSupplier, resolver);
final List<Endpoint> endpoints = endpointSupplier.get();
assertThat(endpoints.size(), equalTo(4));
assertThat(endpoints.get(0).getUri(), equalTo(uri1));
assertThat(endpoints.get(0).getIp(), equalTo(IP_A));
assertThat(endpoints.get(1).getUri(), equalTo(uri1));
assertThat(endpoints.get(1).getIp(), equalTo(IP_B));
assertThat(endpoints.get(2).getUri(), equalTo(uri2));
assertThat(endpoints.get(2).getIp(), equalTo(IP_C));
assertThat(endpoints.get(3).getUri(), equalTo(uri2));
assertThat(endpoints.get(3).getIp(), equalTo(IP_D));
}
@Test
public void testFactory() throws Exception {
final DnsResolver resolver = mock(DnsResolver.class);
when(resolver.resolve("example.com")).thenReturn(IPS_1);
when(resolver.resolve("example.net")).thenReturn(IPS_2);
final List<Endpoint> endpoints = Endpoints.of(uris, resolver);
assertThat(endpoints.size(), equalTo(4));
assertThat(endpoints.get(0).getUri(), equalTo(uri1));
assertThat(endpoints.get(0).getIp(), equalTo(IP_A));
assertThat(endpoints.get(1).getUri(), equalTo(uri1));
assertThat(endpoints.get(1).getIp(), equalTo(IP_B));
assertThat(endpoints.get(2).getUri(), equalTo(uri2));
assertThat(endpoints.get(2).getIp(), equalTo(IP_C));
assertThat(endpoints.get(3).getUri(), equalTo(uri2));
assertThat(endpoints.get(3).getIp(), equalTo(IP_D));
}
@Test
void testGetAndSetDnsResolver()
{
DnsResolver resolver = mock(DnsResolver.class);
config.setDnsResolver(resolver);
assertEquals(resolver, config.getDnsResolver());
}
@Test
public void testBuildDnsResolver()
{
DnsResolver resolver = mock(DnsResolver.class);
config.setDnsResolver(resolver);
testBuildHttpClientUsingConfig();
verify(mockedHttpClientBuilder).setDnsResolver(resolver);
}
@Test
public void testBuildHttpClientAllPossible()
{
String baseUrl = "http://somewh.ere/";
config.setBaseUrl(baseUrl);
config.setHeadersMap(HEADERS);
config.setCredentials(CREDS);
config.setAuthScope(AUTH_SCOPE);
config.setSslCertificateCheckEnabled(false);
config.setSkipResponseEntity(true);
CookieStore cookieStore = new BasicCookieStore();
config.setCookieStore(cookieStore);
config.setSslHostnameVerificationEnabled(false);
DnsResolver resolver = mock(DnsResolver.class);
config.setDnsResolver(resolver);
SSLContext mockedSSLContext = mock(SSLContext.class);
when(mockedSSLContextManager.getSslContext(SSLConnectionSocketFactory.SSL, true))
.thenReturn(Optional.of(mockedSSLContext));
prepareClientBuilderUtilsMock();
testBuildHttpClientUsingConfig();
verify(mockedHttpClientBuilder).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE);
verify(mockedHttpClient).setHttpHost(HttpHost.create(baseUrl));
verify(mockedHttpClient).setSkipResponseEntity(config.isSkipResponseEntity());
verify(mockedHttpClientBuilder).setSSLContext(mockedSSLContext);
verify(mockedHttpClientBuilder).setDefaultCredentialsProvider(credentialsProvider);
verify(mockedHttpClientBuilder).setDefaultCookieStore(cookieStore);
verify(mockedHttpClientBuilder).setDnsResolver(resolver);
verifyDefaultHeaderSetting(HEADERS.entrySet().iterator().next());
PowerMockito.verifyStatic(ClientBuilderUtils.class);
ClientBuilderUtils.createCredentialsProvider(AUTH_SCOPE, CREDS);
}
private DnsResolver nullDnsResolver() {
return new DnsResolver() {
@Override
public InetAddress[] resolve(final String host) throws UnknownHostException {
return new InetAddress[] {null};
}
};
}
@Before
public void setUp() throws Exception {
reactor = new NioReactor();
crusher = TcpCrusherBuilder.builder()
.withReactor(reactor)
.withBindAddress("127.0.0.1", CRUSHER_PORT)
.withConnectAddress(REMOTE_HOST, REMOTE_PORT)
.buildAndOpen();
DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
@Override
public InetAddress[] resolve(final String host) throws UnknownHostException {
if (host.equalsIgnoreCase(REMOTE_HOST)) {
return new InetAddress[] { InetAddress.getByAddress(new byte[] {127, 0, 0, 1}) };
} else {
return super.resolve(host);
}
}
};
HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> httpConnectionFactory =
new ManagedHttpClientConnectionFactory();
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.build();
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(
socketFactoryRegistry, httpConnectionFactory, dnsResolver);
http = HttpClients.createMinimal(connectionManager);
}
public ExtendedConnectionOperator(
Lookup<ConnectionSocketFactory> socketFactoryRegistry,
SchemePortResolver schemePortResolver,
DnsResolver dnsResolver
) {
this.socketFactoryRegistry = socketFactoryRegistry;
this.schemePortResolver = schemePortResolver != null ? schemePortResolver : DefaultSchemePortResolver.INSTANCE;
this.dnsResolver = dnsResolver != null ? dnsResolver : SystemDefaultDnsResolver.INSTANCE;
}
@BeforeClass
public static void setupProxying() {
DnsResolver dnsResolver = prepareProxiedDnsResolver();
DefaultSchemePortResolver schemePortResolver = prepareSchemePortResolver();
BasicHttpClientConnectionManager connManager = prepareConnectionManager(dnsResolver, schemePortResolver);
HttpClient httpClient = prepareHttpClient(connManager);
originalHttpClient = (HttpClient) Options.getOption(Option.HTTPCLIENT);
Unirest.setHttpClient(httpClient);
}
private static BasicHttpClientConnectionManager prepareConnectionManager(DnsResolver dnsResolver, DefaultSchemePortResolver schemePortResolver) {
return new BasicHttpClientConnectionManager(
RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.getSocketFactory())
.register("https", SSLConnectionSocketFactory.getSocketFactory())
.build(),
null,
schemePortResolver,
dnsResolver
);
}
private static DnsResolver prepareProxiedDnsResolver() {
return new SystemDefaultDnsResolver() {
@Override
public InetAddress[] resolve(String host) throws UnknownHostException {
if (host.equalsIgnoreCase("sushi-shop.test")) {
return new InetAddress[]{InetAddress.getByName("127.0.0.1")};
} else {
return super.resolve(host);
}
}
};
}
public FDSHttpClient(FDSClientConfiguration fdsConfig, GalaxyFDSCredential credential,
GalaxyFDSClient fdsClient, DnsResolver dnsResolver) {
this.fdsConfig = fdsConfig;
this.credential = credential;
this.dnsResolver = dnsResolver;
this.fdsClient = fdsClient;
init();
}
public GalaxyFDSClient(GalaxyFDSCredential credential, FDSClientConfiguration fdsConfig,
DnsResolver dnsResolver) {
this.credential = credential;
this.fdsConfig = fdsConfig;
this.dnsResolver = dnsResolver;
init();
}
public TestHttpClientDNSBlackList() {
super(new BasicFDSCredential("AUTH_AK", "AUTH_SK"), defaultFdsConfig,
new DnsResolver() {
@Override
public InetAddress[] resolve(String host) throws UnknownHostException {
++dnsResolvedCnt;
return localIpAddress;
}
});
}
/**
* Returns a {@link Supplier} of a list of {@link Endpoint}.
*
* @param uriSupplier A Supplier of a list of URIs.
* @param dnsResolver An instance of {@link DnsResolver}
*
* @return A Supplier of a list of Endpoints.
*/
static Supplier<List<Endpoint>> of(final Supplier<List<URI>> uriSupplier,
final DnsResolver dnsResolver) {
return new Supplier<List<Endpoint>>() {
@Override
public List<Endpoint> get() {
return of(uriSupplier.get(), dnsResolver);
}
};
}
/**
* Returns a list of {@link Endpoint}.
*
* @param uris A list of URIs.
* @param dnsResolver An instance of {@link DnsResolver}
*
* @return A list of Endpoints.
*/
static List<Endpoint> of(final List<URI> uris, final DnsResolver dnsResolver) {
final ImmutableList.Builder<Endpoint> endpoints = ImmutableList.builder();
for (final URI uri : uris) {
try {
for (final InetAddress ip : dnsResolver.resolve(uri.getHost())) {
endpoints.add(new DefaultEndpoint(uri, ip));
}
} catch (UnknownHostException e) {
log.warn("Unable to resolve hostname {} into IP address", uri.getHost(), e);
}
}
return endpoints.build();
}
@Test
public void testUnableToResolve() throws Exception {
final DnsResolver resolver = mock(DnsResolver.class);
when(resolver.resolve("example.com")).thenThrow(new UnknownHostException());
when(resolver.resolve("example.net")).thenThrow(new UnknownHostException());
final List<Endpoint> endpoints = Endpoints.of(uris, resolver);
assertThat(endpoints.size(), equalTo(0));
}
@Test
public void testInvalidUri_NoScheme() throws Exception {
final DnsResolver resolver = mock(DnsResolver.class);
when(resolver.resolve("example.com")).thenReturn(IPS_1);
exception.expect(IllegalArgumentException.class);
Endpoints.of(ImmutableList.of(new URI(null, "example.com", null, null)), resolver);
}
@Test
public void testInvalidUri_NoPort() throws Exception {
final DnsResolver resolver = mock(DnsResolver.class);
when(resolver.resolve("example.com")).thenReturn(IPS_1);
exception.expect(IllegalArgumentException.class);
Endpoints.of(ImmutableList.of(new URI("http", "example.com", null, null)), resolver);
}
private DnsResolver nullDnsResolver() {
return new DnsResolver() {
@Override
public InetAddress[] resolve(final String host) throws UnknownHostException {
return new InetAddress[] {null};
}
};
}
public DnsResolver getDnsResolver()
{
return dnsResolver;
}
public void setDnsResolver(DnsResolver dnsResolver)
{
this.dnsResolver = dnsResolver;
}
public void setFallbackDnsResolver(DnsResolver fallbackDnsResolver)
{
this.fallbackDnsResolver = fallbackDnsResolver;
}
public DnsResolver getDnsResover() {
return dnsResover;
}
public void setDnsResover(DnsResolver dnsResover) {
this.dnsResover = dnsResover;
}
public DelegatingDnsResolver(com.ibm.cloud.objectstorage.DnsResolver delegate) {
this.delegate = delegate;
}
public BasicHttpClientConnectionManagerWithAlternateDNS(final DnsResolver dnsResolver) {
super(getDefaultRegistry(), null, null, dnsResolver);
}
private CloseableHttpClient getHttpClient() {
//注册访问协议相关的Socket工厂
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", SSLConnectionSocketFactory.getSocketFactory())
.build();
//HttpConnectionFactory:配置写请求/解析响应处理器
HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connectionFactory = new ManagedHttpClientConnectionFactory(
DefaultHttpRequestWriterFactory.INSTANCE,
DefaultHttpResponseParserFactory.INSTANCE
);
//DNS解析器
DnsResolver dnsResolver = SystemDefaultDnsResolver.INSTANCE;
//创建连接池管理器
PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(socketFactoryRegistry, connectionFactory, dnsResolver);
//设置默认的socket参数
manager.setDefaultSocketConfig(SocketConfig.custom().setTcpNoDelay(true).build());
manager.setMaxTotal(300);//设置最大连接数。高于这个值时，新连接请求，需要阻塞，排队等待
//路由是对MaxTotal的细分。
// 每个路由实际最大连接数默认值是由DefaultMaxPerRoute控制。
// MaxPerRoute设置的过小，无法支持大并发：ConnectionPoolTimeoutException:Timeout waiting for connection from pool
manager.setDefaultMaxPerRoute(200);//每个路由的最大连接
manager.setValidateAfterInactivity(5 * 1000);//在从连接池获取连接时，连接不活跃多长时间后需要进行一次验证，默认为2s
//配置默认的请求参数
RequestConfig defaultRequestConfig = RequestConfig.custom()
.setConnectTimeout(2 * 1000)//连接超时设置为2s
.setSocketTimeout(5 * 1000)//等待数据超时设置为5s
.setConnectionRequestTimeout(2 * 1000)//从连接池获取连接的等待超时时间设置为2s
// .setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("192.168.0.2", 1234))) //设置代理
.build();
CloseableHttpClient closeableHttpClient = HttpClients.custom()
.setConnectionManager(manager)
.setConnectionManagerShared(false)//连接池不是共享模式，这个共享是指与其它httpClient是否共享
.evictIdleConnections(60, TimeUnit.SECONDS)//定期回收空闲连接
.evictExpiredConnections()//回收过期连接
.setConnectionTimeToLive(60, TimeUnit.SECONDS)//连接存活时间，如果不设置，则根据长连接信息决定
.setDefaultRequestConfig(defaultRequestConfig)//设置默认的请求参数
.setConnectionReuseStrategy(DefaultConnectionReuseStrategy.INSTANCE)//连接重用策略，即是否能keepAlive
.setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)//长连接配置，即获取长连接生产多长时间
.setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))//设置重试次数，默认为3次；当前是禁用掉
.build();
/**
*JVM停止或重启时，关闭连接池释放掉连接
*/
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
try {
closeableHttpClient.close();
log.info("http client closed");
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
});
return closeableHttpClient;
}
private CloseableHttpClient getHttpClient() {
//注册访问协议相关的Socket工厂
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", SSLConnectionSocketFactory.getSocketFactory())
.build();
//HttpConnectionFactory:配置写请求/解析响应处理器
HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connectionFactory = new ManagedHttpClientConnectionFactory(
DefaultHttpRequestWriterFactory.INSTANCE,
DefaultHttpResponseParserFactory.INSTANCE
);
//DNS解析器
DnsResolver dnsResolver = SystemDefaultDnsResolver.INSTANCE;
//创建连接池管理器
PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(socketFactoryRegistry, connectionFactory, dnsResolver);
//设置默认的socket参数
manager.setDefaultSocketConfig(SocketConfig.custom().setTcpNoDelay(true).build());
manager.setMaxTotal(300);//设置最大连接数。高于这个值时，新连接请求，需要阻塞，排队等待
//路由是对MaxTotal的细分。
// 每个路由实际最大连接数默认值是由DefaultMaxPerRoute控制。
// MaxPerRoute设置的过小，无法支持大并发：ConnectionPoolTimeoutException:Timeout waiting for connection from pool
manager.setDefaultMaxPerRoute(200);//每个路由的最大连接
manager.setValidateAfterInactivity(5 * 1000);//在从连接池获取连接时，连接不活跃多长时间后需要进行一次验证，默认为2s
//配置默认的请求参数
RequestConfig defaultRequestConfig = RequestConfig.custom()
.setConnectTimeout(2 * 1000)//连接超时设置为2s
.setSocketTimeout(5 * 1000)//等待数据超时设置为5s
.setConnectionRequestTimeout(2 * 1000)//从连接池获取连接的等待超时时间设置为2s
// .setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("192.168.0.2", 1234))) //设置代理
.build();
CloseableHttpClient closeableHttpClient = HttpClients.custom()
.setConnectionManager(manager)
.setConnectionManagerShared(false)//连接池不是共享模式，这个共享是指与其它httpClient是否共享
.evictIdleConnections(60, TimeUnit.SECONDS)//定期回收空闲连接
.evictExpiredConnections()//回收过期连接
.setConnectionTimeToLive(60, TimeUnit.SECONDS)//连接存活时间，如果不设置，则根据长连接信息决定
.setDefaultRequestConfig(defaultRequestConfig)//设置默认的请求参数
.setConnectionReuseStrategy(DefaultConnectionReuseStrategy.INSTANCE)//连接重用策略，即是否能keepAlive
.setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)//长连接配置，即获取长连接生产多长时间
.setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))//设置重试次数，默认为3次；当前是禁用掉
.build();
/**
*JVM停止或重启时，关闭连接池释放掉连接
*/
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
try {
LOGGER.info("closing http client");
closeableHttpClient.close();
LOGGER.info("http client closed");
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
}
});
return closeableHttpClient;
}
public InternalSiteBlackListDNSResolver(IPAddressBlackList blackList,
DnsResolver dnsResolver) {
this.blackList = blackList;
this.dnsResolver = dnsResolver;
}