Of Stack

Configuration and usage of restTemplate of Springboot

  • 2021-12-05 06:14:33
  • OfStack
Directory Basic Configuration the following is Advanced Configuration and Use 1 Scenario 2 Dependence 3 Configuration 4 Use 4.1 GET Request 4.2 POST Request 4.3 Upload File

In the springboot project, RestTemplate can be directly injected or simply configured

Basic configuration 


@Configuration
public class RestTemplateConfig {
   @Bean
   public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
       return new RestTemplate(factory);
   }
   @Bean
   public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
       SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
       factory.setReadTimeout(150000); // ms
       factory.setConnectTimeout(150000); // ms
       return factory;
   }
}

The following are advanced configuration and use

1 Scenario

In the development of java, http is used to connect and access the third-party network interface, and the commonly used connection tools are HttpClient and OKHttp.

These two kinds of connection tools are complicated to use, and novices are prone to problems. If you use the spring framework, you can use restTemplate to make http connection requests.

The default connection mode of restTemplate is HttpConnection in java, and you can use ClientHttpRequestFactory to specify different connection modes of HTTP.

2 Dependence

maven depends on the following: 


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.7</version>
</dependency>

3 Configuration 


import org.apache.http.client.HttpClient;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
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 {
    
    /**
     * http Connection Manager 
     * @return
     */
    @Bean
    public HttpClientConnectionManager poolingHttpClientConnectionManager() {
        /*//  Registration http And https Request 
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", SSLConnectionSocketFactory.getSocketFactory())
                .build();
        PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(registry);*/
        
        PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
        //  Maximum number of connections 
        poolingHttpClientConnectionManager.setMaxTotal(500);
        //  Same route concurrency (concurrency per host) 
        poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100);
        return poolingHttpClientConnectionManager;
    }
    
    /**
     * HttpClient
     * @param poolingHttpClientConnectionManager
     * @return
     */
    @Bean
    public HttpClient httpClient(HttpClientConnectionManager poolingHttpClientConnectionManager) {
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        //  Settings http Connection Manager 
        httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);
        
        /*//  Set the number of retries 
        httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true));*/
        
        //  Set the default request header 
        /*List<Header> headers = new ArrayList<>();
        headers.add(new BasicHeader("Connection", "Keep-Alive"));
        httpClientBuilder.setDefaultHeaders(headers);*/        
        return httpClientBuilder.build();
    }
    
    /**
     *  Request connection pool configuration 
     * @param httpClient
     * @return
     */
    @Bean
    public ClientHttpRequestFactory clientHttpRequestFactory(HttpClient httpClient) {
        HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory();
        // httpClient Creator 
        clientHttpRequestFactory.setHttpClient(httpClient);
        //  Connection timeout / Milliseconds (connect to the server ( Successful handshake ) Time beyond throwing connect timeout ) 
        clientHttpRequestFactory.setConnectTimeout(5 * 1000);
        //  Data read timeout (socketTimeout)/ Milliseconds (server returns data (response) Exceeds the time of throwing read timeout ) 
        clientHttpRequestFactory.setReadTimeout(10 * 1000);
        //  The timeout time for connection pool to get the requested connection should not be too long, and must be set / Milliseconds (if you don't get an available connection after the time limit, you will throw org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool ) 
        clientHttpRequestFactory.setConnectionRequestTimeout(10 * 1000);
        return clientHttpRequestFactory;
    }
    
    /**
     * rest Template 
     * @return
     */
    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory clientHttpRequestFactory) {
        // boot Can be used in RestTemplateBuilder.build Create 
        RestTemplate restTemplate = new RestTemplate();
        //  Configure the request factory 
        restTemplate.setRequestFactory(clientHttpRequestFactory);
        return restTemplate;
    }    
}

4 Use

The entity classes used are as follows: 


    @Data
    @ToString
    public class TempUser implements Serializable {
        private String userName;   
        private Integer age;
    }

4.1 GET Request

Background interface code: 


    @RequestMapping("getUser")
    public TempUser getUser(TempUser form) {
        TempUser tempUser = new TempUser();
        tempUser.setUserName(form.getUserName());
        tempUser.setAge(form.getAge());
        return tempUser;
    }

4.1. 1 Ordinary access 


TempUser result = restTemplate.getForObject("http://localhost:8080/cs-admin/rest/getUser?userName= Zhang 3&amp;age=18", TempUser.class);

4.1. 2 Return to HTTP status 


ResponseEntity<TempUser> responseEntity = restTemplate.getForEntity("http://localhost:8080/cs-admin/rest/getUser?userName= Zhang 3&age=18", TempUser.class);
//  Get the status object 
HttpStatus httpStatus = responseEntity.getStatusCode();
//  Get status code 
int statusCodeValue = responseEntity.getStatusCodeValue();
//  Get headers
HttpHeaders httpHeaders = responseEntity.getHeaders();
//  Get body
TempUser result = responseEntity.getBody();

4.1. 3 Mapping request parameters 


Map<String, Object> paramMap = new HashMap<>();
paramMap.put("userName", " Zhang 3");
paramMap.put("age", 18);
TempUser result = restTemplate.getForObject("http://localhost:8080/cs-admin/rest/getUser?userName={userName}&age={age}", TempUser.class, paramMap);

4.2 POST Request

4.2. 1 Normal access

Background interface code: 


 RequestMapping("getPostUser")
    public TempUser getPostUser(@RequestBody TempUser form) {
    TempUser tempUser = new TempUser();
    tempUser.setUserName(form.getUserName());
    tempUser.setAge(form.getAge());
    return tempUser;
}

(1) Common Access Interface 


TempUser param = new TempUser();
param.setUserName(" Zhang 3");
param.setAge(18);
TempUser result = restTemplate.postForObject("http://localhost:8080/cs-admin/rest/getPostUser", param, TempUser.class);

(2) With HEAD access interface 


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.7</version>
</dependency>
0

4.2. 2 Access without Requestor Body

Only method is post, and the mode of parameter transmission is still param of get

Background interface code: 


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.7</version>
</dependency>
1

Access method: 


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.7</version>
</dependency>
2

4.3 Upload File

Background interface code: 


@RequestMapping("uploadFile")
public TempUser uploadFile(HttpServletRequest request, TempUser form) {
 MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
 // Get file information 
 MultipartFile multipartFile = multipartHttpServletRequest.getFile("file");
 TempUser tempUser = new TempUser();
 if (multipartFile != null) {
     tempUser.setUserName(form.getUserName()+" "+multipartFile.getOriginalFilename());
 }
 if(form!=null){
     tempUser.setAge(form.getAge());
 }
 return tempUser;
}

Access method: 


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.7</version>
</dependency>
4
Related articles: