logo
  2. 首页
  3. 编程教程
  4. Java
  5. HttpClient的RestTemplate - Java配置示例
  6. 详情

HttpClient的RestTemplate - Java配置示例

编程教程 > Java (2233) 2024-11-26 14:39:04

HttpClient配置

在HttpClientConfig课堂上，我们主要配置两件事 -

  1. PoolingHttpClientConnectionManager - 顾名思义，它的连接池管理器。在这里，连接按照每个路线进行汇集。对于已经是管理器具有可用于池中的持续连接的路由的请求将是通过从池租用连接而不是创建全新连接的服务。

    ConnectionKeepAliveStrategy 有助于设置时间，这决定了连接在重新使用之前可以保持空闲状态的时间。

  2. 并设置一个idleConnectionMonitor线程，它会定期检查所有连接并释放尚未使用的空闲时间和空闲时间。

真正使用的http客户端是CloseableHttpClientbean。它将RestTemplate用于获取与API端点的连接。
 

import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeUnit;
 
import org.apache.http.HeaderElement;
import org.apache.http.HeaderElementIterator;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContextBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
 
/**
 * - Supports both HTTP and HTTPS
 * - Uses a connection pool to re-use connections and save overhead of creating connections.
 * - Has a custom connection keep-alive strategy (to apply a default keep-alive if one isn't specified)
 * - Starts an idle connection monitor to continuously clean up stale connections.
 */
@Configuration
@EnableScheduling
public class HttpClientConfig {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientConfig.class);
 
    // Determines the timeout in milliseconds until a connection is established.
    private static final int CONNECT_TIMEOUT = 30000;
     
    // The timeout when requesting a connection from the connection manager.
    private static final int REQUEST_TIMEOUT = 30000;
     
    // The timeout for waiting for data
    private static final int SOCKET_TIMEOUT = 60000;
 
    private static final int MAX_TOTAL_CONNECTIONS = 50;
    private static final int DEFAULT_KEEP_ALIVE_TIME_MILLIS = 20 * 1000;
    private static final int CLOSE_IDLE_CONNECTION_WAIT_TIME_SECS = 30;
 
    @Bean
    public PoolingHttpClientConnectionManager poolingConnectionManager() {
        SSLContextBuilder builder = new SSLContextBuilder();
        try {
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        } catch (NoSuchAlgorithmException | KeyStoreException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }
 
        SSLConnectionSocketFactory sslsf = null;
        try {
            sslsf = new SSLConnectionSocketFactory(builder.build());
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }
 
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
                .<ConnectionSocketFactory>create().register("https", sslsf)
                .register("http", new PlainConnectionSocketFactory())
                .build();
 
        PoolingHttpClientConnectionManager poolingConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        poolingConnectionManager.setMaxTotal(MAX_TOTAL_CONNECTIONS);
        return poolingConnectionManager;
    }
 
    @Bean
    public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
        return new ConnectionKeepAliveStrategy() {
            @Override
            public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
                HeaderElementIterator it = new BasicHeaderElementIterator
                        (response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while (it.hasNext()) {
                    HeaderElement he = it.nextElement();
                    String param = he.getName();
                    String value = he.getValue();
 
                    if (value != null && param.equalsIgnoreCase("timeout")) {
                        return Long.parseLong(value) * 1000;
                    }
                }
                return DEFAULT_KEEP_ALIVE_TIME_MILLIS;
            }
        };
    }
 
    @Bean
    public CloseableHttpClient httpClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(REQUEST_TIMEOUT)
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT).build();
 
        return HttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(poolingConnectionManager())
                .setKeepAliveStrategy(connectionKeepAliveStrategy())
                .build();
    }
     
    @Bean
    public Runnable idleConnectionMonitor(final PoolingHttpClientConnectionManager connectionManager) {
        return new Runnable() {
            @Override
            @Scheduled(fixedDelay = 10000)
            public void run() {
                try {
                    if (connectionManager != null) {
                        LOGGER.trace("run IdleConnectionMonitor - Closing expired and idle connections...");
                        connectionManager.closeExpiredConnections();
                        connectionManager.closeIdleConnections(CLOSE_IDLE_CONNECTION_WAIT_TIME_SECS, TimeUnit.SECONDS);
                    } else {
                        LOGGER.trace("run IdleConnectionMonitor - Http Client Connection manager is not initialised");
                    }
                } catch (Exception e) {
                    LOGGER.error("run IdleConnectionMonitor - Exception occurred. msg={}, e={}", e.getMessage(), e);
                }
            }
        };
    }
}

RestTemplate配置

在这里，我们正在配置RestTemplate我们最终将用来调用REST API的bean。如上所述，它使用CloseableHttpClientbean实例来构建ClientHttpRequestFactory，用于创建RestTemplate。

  1. HttpComponentsClientHttpRequestFactory是ClientHttpRequestFactory使用Apache HttpComponents HttpClient创建请求的实现。
  2. 我们@Scheduled在httpClient配置中使用了注释。为了支持这个，我们必须添加对线程预定执行的支持。为此，我们使用了ThreadPoolTaskScheduler内部使用ScheduledThreadPoolExecutor的 bean 来安排命令在给定的延迟后运行，或者定期执行。
import org.apache.http.impl.client.CloseableHttpClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.web.client.RestTemplate;
 
public class RestTemplateConfig {
 
    @Autowired
    CloseableHttpClient httpClient;
 
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());
        return restTemplate;
    }
 
    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory();
        clientHttpRequestFactory.setHttpClient(httpClient);
        return clientHttpRequestFactory;
    }
 
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("poolScheduler");
        scheduler.setPoolSize(50);
        return scheduler;
    }
}

如何使用RestTemplate

要使用上述配置RestTemplate，只需将其注入控制器或测试类。

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.client.RestTemplate;
 
import com.xqlee.config.HttpClientConfig;
import com.xqlee.config.RestTemplateConfig;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { RestTemplateConfig.class, HttpClientConfig.class })
public class TestApplication {
 
    @Autowired
    RestTemplate restTemplate;
 
    @Test
    public void getEmployees() {
        final String uri = "http://localhost:8080/employees";
 
        String result = restTemplate.getForObject(uri, String.class);
 
        Assert.assertEquals(true, result.indexOf("Lokesh") > 0);
    }
}

Maven的依赖

首先，你将被要求有两个依赖关系，即httpclient和spring-web。我正在使用spring启动应用程序，所以pom文件如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.xqlee</groupId>
    <artifactId>springbootdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>springbootdemo</name>
    <url>http://maven.apache.org</url>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
 
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
 
    <dependencies>
     
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-hateoas</artifactId>
        </dependency>
         
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>
http://blog.xqlee.com/article/422.html
评论
User Image
提示：请评论与当前内容相关的回复，广告、推广或无关内容将被删除。
相关文章
HttpClient的RestTemplate - Java配置示例
HttpClient的RestTemplate - Java配置示例
HttpClient的RestTemplate - Java配置示例
RestTemplate httpclient java
HttpClient 使用SSL访问HTTPS（提高篇）
HttpClient 使用SSL访问HTTPS（提高篇）
本文将展示如何使用“接受所有”SSL支持来配置Apache HttpClient 4。目标很简单 - 使用没有有效证书的HTTPS URL。
httpclient java
RestTemplate处理非200返回_RestTemplate处理错误返回
RestTemplate处理非200返回_RestTemplate处理错误返回
问题描述默认情况下，在使用spring的restTemplate调用接口，如果响应的http状态码是200则会成功返回数据
RestTemplate非200处理 RestTemplate错误处理 Spring Boot Spring Cloud
HttpClient 4.x 使用详解（基础篇）
HttpClient 4.x 使用详解（基础篇）
Apache HttpClient 4.x 使用详解
httpclient java
HttpClient 4.x POST请求（基础篇）
HttpClient 4.x POST请求（基础篇）
在本教程中 - 我们将使用HttpClient 4进行POST - 首先使用授权，然后使用流畅的HttpClient API。最后 - 我们将讨论如何使用HttpClient上传文件。
httpclient java
HttpClient Basic Authentication基本认证
HttpClient Basic Authentication基本认证
HttpClient Basic Authentication基本认证，本教程将说明如何在Apache HttpClient 4上配置基本身份验证。
httpclient Java
HttpClient 4 按照POST重定向请求
HttpClient 4 按照POST重定向请求
HttpClient 4 按照POST重定向请求，本快速教程将展示如何配置Apache HttpClient 4以自动遵循POST请求的重定向。
httpclient Java
Apache httpclient4.5 GET/POST/PUT/OPTION/DELETE工具类
Apache httpclient4.5 GET/POST/PUT/OPTION/DELETE工具类
Apache httpclient4.5 GET/POST/PUT/OPTION/DELETE工具类
httpclient java
java编程中采用Apache common.httpclient方式模拟POST请求
java编程中采用Apache common.httpclient方式模拟POST请求
java编程中采用Apache common.httpclient方式模拟POST请求
Java编程 Java post Apache
HttpClient 4 发送自定义的Cookie
HttpClient 4 发送自定义的Cookie
1.概述本教程将重点介绍如何使用Apache HttpClient 4发送自定义Cookie
httpclient HttpClient 发送cookie
HttpClient 4 分段上传（Multipart Upload）
HttpClient 4 分段上传（Multipart Upload）
HttpClient 4 分段上传文件，在本教程中，我们将演示如何使用HttpClient 4执行分段上传操作。
httpclient Java
HttpClient 还原缩短URL地址（提高篇）
HttpClient 还原缩短URL地址（提高篇）
在本文中，我们将演示如何使用 HttpClient 解除URL的绑定。一个简单的例子就是当原始URL被缩短一次 - 通过诸如bit.ly的服务。一个更复杂的例子是，URL被多次缩短，被不同的服务...
httpclient Java
java 原生HTTP CLIENT实现GET/POST请求
java 原生HTTP CLIENT实现GET/POST请求
java 以http client的post/get方式访问指定urlimport java.io.BufferedReader;import java.io.
Java httpclient httpclient工具类
Java编程之Spring Cloud Hystrix Circuit熔断/断路
Java编程之Spring Cloud Hystrix Circuit熔断/断路
Java编程之Spring Cloud Hystrix Circuit熔断/断路
Java编程 spring框架
Java 11 新特性和增强功能说明
Java 11 新特性和增强功能说明
Java 11（2018 年 9 月发布）包含许多重要且有用的更新
Java 11 新特性 Java11 jdk11 Java