java uses RestTemplate to encapsulate post request mode
- 2021-12-04 18:58:07
- OfStack
Directory uses RestTemplate to encapsulate post to request RestTemplate to use encapsulation 1, SpringBoot to use RestTemplate (httpclient using apache) 2, jdk native 2, interceptor to implement ClientHttpRequestInterceptor4, common method
Encapsulating post requests with RestTemplate
Before, the author wrote a practical article java, which uses httpclient to encapsulate post requests and get requests. In fact, http requests in java can also be completed with RestTemplate. The following example code is given:
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.*;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
public class HttpHelper {
private static Logger logger = LoggerFactory.getLogger(HttpHelper.class);
private RestTemplate restTemplate;
private HttpHeaders httpHeaders;
@PostConstruct
public void init() {
restTemplate = new RestTemplate();
restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
httpHeaders = new HttpHeaders();
httpHeaders.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
}
/**
* post - json
* @param params
* @return
*/
public String post(JSONObject params, String url) {
logger.info(" Request parameters: {}", params.toJSONString());
ResponseEntity<String> response;
try {
response = restTemplate.exchange(
url,
HttpMethod.POST,
new HttpEntity<>(params, httpHeaders),
String.class);
} catch (Exception e) {
logger.error(" Request exception ", e);
return " Request exception ";
}
logger.info(" Response result: {}", JSONObject.toJSONString(response));
if (response.getStatusCode().equals(HttpStatus.OK)) {
logger.info(" The request is successful and the result is returned: {}", response.getBody());
return response.getBody();
}
logger.error(" The request failed, Http Status code: {} Returns the result: {}", response.getStatusCode(), response.getBody());
return response.getBody();
}
}
RestTemplate is a client provided by Spring for accessing Rest services, and RestTemplate provides a variety of convenient methods for accessing remote Http services, which can greatly improve the writing efficiency of clients.
RestTemplate uses encapsulation
Before the interface call habitually used HttpClient, the code is complex and redundant, so it is not very cool to care about resource recovery.
RestTemplate relies by default on HTTP Connection Utility for jdk. You can also switch to different HTTP sources through the setRequestFactory attribute, such as Apache, HttpComponents, Netty, OkHttp.
1. SpringBoot uses RestTemplate (httpclient using apache)
import org.springframework.boot.web.client.RestTemplateBuilder;
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.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.ResourceHttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate getRestTemplate() {
// Manually specify the converter (HttpMessageConverter)
List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
messageConverters.add(new ByteArrayHttpMessageConverter());
messageConverters.add(new StringHttpMessageConverter(Charset.forName("UTF-8")));//string Mandatory use UTF-8
messageConverters.add(new ResourceHttpMessageConverter());
messageConverters.add(new AllEncompassingFormHttpMessageConverter());
messageConverters.add(new FormHttpMessageConverter());
MappingJackson2HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter();
jacksonConverter.getObjectMapper().setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
messageConverters.add(jacksonConverter);
RestTemplate restTemplate = new RestTemplateBuilder().additionalMessageConverters(messageConverters).build();
restTemplate.setRequestFactory(getClientHttpRequestFactory());
return restTemplate;
}
@Bean
public ClientHttpRequestFactory getClientHttpRequestFactory() {
// To maintain the long connection configuration, you need to add it in the header Keep-Alive
final ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {
@Override
public long getKeepAliveDuration(org.apache.http.HttpResponse response, HttpContext context) {
// Settings 1 Maximum lifetime of links
return 5 * 1000L;
}
};
PoolingHttpClientConnectionManager pollingConnectionManager = new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
pollingConnectionManager.setMaxTotal(2000);// Maximum number of connections
pollingConnectionManager.setDefaultMaxPerRoute(200);// Maximum number of connections on the same route
CloseableHttpClient closeableHttpClient = HttpClientBuilder.create().setConnectionManager(pollingConnectionManager).setKeepAliveStrategy(myStrategy).build();
HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(closeableHttpClient);
factory.setConnectTimeout(3000);
factory.setReadTimeout(5000);
return factory;
}
}
2. Use jdk native
// Add a message converter
List messageConverters = new ArrayList();
messageConverters.add(new StringHttpMessageConverter());
messageConverters.add(new MappingJackson2HttpMessageConverter());
// If useJ2SEHttp Declare as true, Use the JDK Bring your own HttpURLConnection
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setReadTimeout(3000);
requestFactory.setConnectTimeout(3000);
restTemplate = new RestTemplate(requestFactory);
restTemplate.setMessageConverters(messageConverters);
// Here is the interceptor added
List<ClientHttpRequestInterceptor> interceptorList = new ArrayList<ClientHttpRequestInterceptor>();
interceptorList.add(new RequestInteceptor());
restTemplate.setInterceptors(interceptorList);
2. Interceptor implements ClientHttpRequestInterceptor
(Reused when setting header information)
public class RequestInteceptor implements ClientHttpRequestInterceptor {
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
request.getHeaders().setAll(AppMetadataUtil.getAPP_METADATA());
String traceId = UUID.randomUUID().toString().replaceAll("-", "");
request.getHeaders().set("TraceId", traceId.toString());
return execution.execute(request, body);
}
}
4. Commonly used methods
String url = queryInfo?userId={userId}&pageIndex={pageIndex}&pageSize={pageSize}";
HashMap<String,Object> parameterMap = new HashMap<String,Object>();
parameterMap.put("userId", userId);
parameterMap.put("pageIndex", pageIndex);
parameterMap.put("pageSize", pageSize);
String str = restTemplate.getForObject(url, String.class, parameterMap);
String result = restTemp.getForObject(requestUrl.toString(), String.class);
//post
String url = "http://www.xxx.com/queryInfo"
String str = restTemplate.postForObject(url, parameterMap, String.class);
//exchange Set the request header
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
headers.add("Accept", "application/json;charset=UTF-8");
HttpEntity<String> httpEntity = new HttpEntity<String>("", headers);
RestTemplate restTemplate = RestTemplateUtils.getInstance().getRestTemplate();
ResponseEntity<String> exchange = restTemplate.exchange(retailOrderUrl, HttpMethod.GET, httpEntity, String.class);
String forObject = exchange.getBody();
MultiValueMap<String, Object> requestEntity = new LinkedMultiValueMap<>();