springboot集成RestTemplate

             RestTemplate其实是spring框架对Apache HttpClient的封装。

             对比一下用法：

             先看HttpClient

 /**
	     * 带参数的post请求 .
	     * 
	     * @param url .
	     * @param map .
	     * @return .
	     * @throws Exception .
	     */
	    public HttpResult doPost(String url, Map<String, Object> map) throws Exception {
	    	logger.info("doPost请求url="+url);
	        // 声明httpPost请求
	        HttpPost httpPost = new HttpPost(url);
	        // 加入配置信息
	        httpPost.setConfig(config);
	 
	        // 判断map是否为空，不为空则进行遍历，封装from表单对象
	        if (map != null) {
	            List<NameValuePair> list = new ArrayList<NameValuePair>();
	            for (Map.Entry<String, Object> entry : map.entrySet()) {
	                list.add(new BasicNameValuePair(entry.getKey(), (String)entry.getValue()));
	            }
	            // 构造from表单对象
	            UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(list, "UTF-8");
	 
	            // 把表单放到post里
	            httpPost.setEntity(urlEncodedFormEntity);
	        }
	 
	        // 发起请求
	        CloseableHttpResponse response = this.httpClient.execute(httpPost);
	        String respBody=EntityUtils.toString(response.getEntity(), "UTF-8");
	        return new HttpResult(response.getStatusLine().getStatusCode(), respBody);
	    }

          再看RestTemplate

	public void postForEntity(String url, Map<String, Object> params) {
		
		ResponseEntity<String> responseEntity = restTemplate.postForEntity(url,params, String.class);
		System.out.println(responseEntity.getBody());
	}

        代码简洁多了。

        开始我们的实验。

        第一步：引入依赖

         

 <!-- 20210824引入resttemplate依赖 -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.6</version>
		</dependency>

       第二步：application.properties中配置属性

#resttempate配置
#连接池最大连接数
http.maxTotal: 100
#并发数
http.defaultMaxPerRoute: 20
#创建连接的最长时间
http.connectTimeout: 10000
#从连接池中获取到连接的最长时间，单位毫秒
http.connectionRequestTimeout: 5000
#数据传输的最长时间
http.socketTimeout: 10000
#提交请求前测试连接是否可用
http.staleConnectionCheckEnabled: true
#可用空闲连接过期时间,重用空闲连接时会先检查是否空闲时间超过这个时间，如果超过，释放socket重新建立
http.validateAfterInactivity: 3000000

       第三步：配置bean,RestTemplateConfig.java

/**
 * 
 */
package com.figo.springboottest.config;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
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.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    @Value("${http.maxTotal}")
    private Integer maxTotal;

    @Value("${http.defaultMaxPerRoute}")
    private Integer defaultMaxPerRoute;

    @Value("${http.connectTimeout}")
    private Integer connectTimeout;

    @Value("${http.connectionRequestTimeout}")
    private Integer connectionRequestTimeout;

    @Value("${http.socketTimeout}")
    private Integer socketTimeout;

    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;

    @Value("${http.validateAfterInactivity}")
    private Integer validateAfterInactivity;


    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate(httpRequestFactory());
    }

    @Bean
    public ClientHttpRequestFactory httpRequestFactory() {
        return new HttpComponentsClientHttpRequestFactory(httpClient());
    }

    @Bean
    public HttpClient httpClient() {
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", SSLConnectionSocketFactory.getSocketFactory())
                .build();
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
        connectionManager.setMaxTotal(maxTotal); // 最大连接数
        connectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);    //单个路由最大连接数
        connectionManager.setValidateAfterInactivity(validateAfterInactivity); // 最大空间时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(socketTimeout)        //服务器返回数据(response)的时间，超过抛出read timeout
                .setConnectTimeout(connectTimeout)      //连接上服务器(握手成功)的时间，超出抛出connect timeout
                .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled) // 提交前检测是否可用
                .setConnectionRequestTimeout(connectionRequestTimeout)//从连接池中获取连接的超时时间，超时间未拿到可用连接，会抛出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool
                .build();
        return HttpClientBuilder.create()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(connectionManager)
                .build();
    }

}

             第四步：单元测试

/**
 * 
 */
package com.figo.springboottest;

import java.util.HashMap;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

/**
 * @author figo
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class RestTemplateTest {
	@Autowired
	RestTemplate restTemplate;

	@Test
	public void testGetForEntity() {
		ResponseEntity<String> responseEntity = restTemplate.getForEntity("https://mobile-test.figo.com/test/",
				String.class, "张三");
		System.out.println(responseEntity.getBody());
		;
	}

	@Test
	public void testGetForObject() {
		String result = restTemplate.getForObject("https://mobile-test.figo.com/test/", String.class, "张三");
		System.out.println(result);
		;
	}

	@Test
	public void testPostForEntity() {
		ResponseEntity<String> responseEntity = restTemplate.postForEntity("https://mobile-test.figo.com/test/",
				"张三", String.class);
		System.out.println(responseEntity.getBody());
		 
		Map<String, Object> params=new HashMap<String,Object>();
		 //postForEntity("https://mobile-test.figo.com/test/",params);
	}


	public void postForEntity(String url, Map<String, Object> params) {
		
		ResponseEntity<String> responseEntity = restTemplate.postForEntity(url,params, String.class);
		System.out.println(responseEntity.getBody());
	}
	
	@Test
	public void testPostForObject() {
		String result = restTemplate.postForObject("https://mobile-test.figo.com/test/", "张三", String.class);
		System.out.println(result);
	}
	
}

 参考文章：https://www.cnblogs.com/yuexiaoyun/articles/13034028.html