工具类之关于RestTemplateUtil工具类的使用

目录

工具类-RestTemplateUtil工具类

代码可直接复制使用

RestTemplate配置类和工具类

工具类-RestTemplateUtil工具类


代码可直接复制使用

配置RestTemplate

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.http.client.SimpleClientHttpRequestFactory;
4. import org.springframework.web.client.RestTemplate;
6. @Configuration
7. public class RestTemplateConfig {
9.     @Bean
10.     public RestTemplate restTemplate() {
11.         SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
12.         requestFactory.setConnectTimeout(60000);
13.         requestFactory.setReadTimeout(60000);
14.         //使用okhttp
15.         //RestTemplate restTemplate = new RestTemplate(new OkHttp3ClientHttpRequestFactory());
16.         RestTemplate restTemplate = new RestTemplate(requestFactory);
17.         return restTemplate;
18.     }
19. }

复制代码

RestTemplateUtil工具类

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.http.HttpEntity;
3. import org.springframework.http.HttpHeaders;
4. import org.springframework.http.HttpMethod;
5. import org.springframework.http.ResponseEntity;
6. import org.springframework.stereotype.Component;
7. import org.springframework.web.client.RestTemplate;
9. /**
10. * RestTemplateUtil工具类
11. */
12. @Component
13. public class RestTemplateUtil {
15.     @Autowired
16.     private RestTemplate restTemplate;
17.   /*  private static class SingletonRestTemplate {
19.         static final RestTemplate INSTANCE = new RestTemplate();
20.     }
22.     private RestTemplateUtil() {
23.     }
25.     public static RestTemplate getInstance() {
26.         return SingletonRestTemplate.INSTANCE;
27.     }*/
29.     /**
30.      * post 请求
31.      *
32.      * @param url  请求路径
33.      * @param data body数据
34.      * @return
35.      */
36.     public String post(String url, String data) {
37.         HttpHeaders headers = new HttpHeaders();
38.         headers.add("Accept", "application/json");
39.         headers.add("Content-Encoding", "UTF-8");
40.         headers.add("Content-Type", "application/json; charset=UTF-8");
41.         HttpEntity<String> requestEntity = new HttpEntity<>(data, headers);
42.         return restTemplate.postForObject(url, requestEntity, String.class);
43.     }
45.     /**
46.      * get 请求
47.      *
48.      * @param url   请求路径
49.      * @param token JWT所需的Token，不需要的可去掉
50.      * @return
51.      */
52.     public String get(String url, String token) {
53.         HttpHeaders headers = new HttpHeaders();
54.         headers.add("Accept", "application/json");
55.         headers.add("Content-Encoding", "UTF-8");
56.         headers.add("Content-Type", "application/json; charset=UTF-8");
57.         if (token != null) {
58.             headers.add("Authorization", token);
59.         }
60.         HttpEntity<String> requestEntity = new HttpEntity<>(null, headers);
61.         ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
62.         String responseBody = response.getBody();
63.         return responseBody;
64.     }
65. /**
66.      * get 请求
67.      *
68.      * @param url   请求路径
69.      * @return
70.      */
72.     public  <T> T getWithSession(String url, String sessionId, Class<T> responseType, Object... uriVariables) {
73.         HttpHeaders httpHeaders = new HttpHeaders();
74.         httpHeaders.add("session_id", sessionId);
75.         return get(url, httpHeaders, responseType, uriVariables).getBody();
76.     }
78.     // ----------------------------------GET-------------------------------------------------------
80.     /**
81.      * GET请求调用方式
82.      *
83.      * @param url 请求URL
84.      * @param responseType 返回对象类型
85.      * @return ResponseEntity 响应对象封装类
86.      */
87.     public  <T> ResponseEntity<T> get(String url, Class<T> responseType) {
88.         return restTemplate.getForEntity(url, responseType);
89.     }
91.     /**
92.      * GET请求调用方式
93.      *
94.      * @param url 请求URL
95.      * @param responseType 返回对象类型
96.      * @param uriVariables URL中的变量，按顺序依次对应
97.      * @return ResponseEntity 响应对象封装类
98.      */
99.     public  <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
100.         return restTemplate.getForEntity(url, responseType, uriVariables);
101.     }
103.     /**
104.      * GET请求调用方式
105.      *
106.      * @param url 请求URL
107.      * @param responseType 返回对象类型
108.      * @param uriVariables URL中的变量，与Map中的key对应
109.      * @return ResponseEntity 响应对象封装类
110.      */
111.     public  <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
112.         return restTemplate.getForEntity(url, responseType, uriVariables);
113.     }
115.     /**
116.      * 带请求头的GET请求调用方式
117.      *
118.      * @param url 请求URL
119.      * @param headers 请求头参数
120.      * @param responseType 返回对象类型
121.      * @param uriVariables URL中的变量，按顺序依次对应
122.      * @return ResponseEntity 响应对象封装类
123.      */
124.     public  <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
125.         HttpHeaders httpHeaders = new HttpHeaders();
126.         httpHeaders.setAll(headers);
127.         return get(url, httpHeaders, responseType, uriVariables);
128.     }
130.     /**
131.      * 带请求头的GET请求调用方式
132.      *
133.      * @param url 请求URL
134.      * @param headers 请求头参数
135.      * @param responseType 返回对象类型
136.      * @param uriVariables URL中的变量，按顺序依次对应
137.      * @return ResponseEntity 响应对象封装类
138.      */
139.     public  <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
140.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
141.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
142.     }
144.     /**
145.      * 带请求头的GET请求调用方式
146.      *
147.      * @param url 请求URL
148.      * @param headers 请求头参数
149.      * @param responseType 返回对象类型
150.      * @param uriVariables URL中的变量，与Map中的key对应
151.      * @return ResponseEntity 响应对象封装类
152.      */
153.     public  <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
154.         HttpHeaders httpHeaders = new HttpHeaders();
155.         httpHeaders.setAll(headers);
156.         return get(url, httpHeaders, responseType, uriVariables);
157.     }
159.     /**
160.      * 带请求头的GET请求调用方式
161.      *
162.      * @param url 请求URL
163.      * @param headers 请求头参数
164.      * @param responseType 返回对象类型
165.      * @param uriVariables URL中的变量，与Map中的key对应
166.      * @return ResponseEntity 响应对象封装类
167.      */
168.     public  <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
169.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
170.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
171.     }
173.     // ----------------------------------POST-------------------------------------------------------
175.     /**
176.      * POST请求调用方式
177.      *
178.      * @param url 请求URL
179.      * @param responseType 返回对象类型
180.      * @return
181.      */
182.     public  <T> ResponseEntity<T> post(String url, Class<T> responseType) {
183.         return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
184.     }
186.     /**
187.      * POST请求调用方式
188.      *
189.      * @param url 请求URL
190.      * @param requestBody 请求参数体
191.      * @param responseType 返回对象类型
192.      * @return ResponseEntity 响应对象封装类
193.      */
194.     public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
195.         return restTemplate.postForEntity(url, requestBody, responseType);
196.     }
198.     /**
199.      * POST请求调用方式
200.      *
201.      * @param url 请求URL
202.      * @param requestBody 请求参数体
203.      * @param responseType 返回对象类型
204.      * @param uriVariables URL中的变量，按顺序依次对应
205.      * @return ResponseEntity 响应对象封装类
206.      */
207.     public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
208.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
209.     }
211.     /**
212.      * POST请求调用方式
213.      *
214.      * @param url 请求URL
215.      * @param requestBody 请求参数体
216.      * @param responseType 返回对象类型
217.      * @param uriVariables URL中的变量，与Map中的key对应
218.      * @return ResponseEntity 响应对象封装类
219.      */
220.     public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
221.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
222.     }
224.     /**
225.      * 带请求头的POST请求调用方式
226.      *
227.      * @param url 请求URL
228.      * @param headers 请求头参数
229.      * @param requestBody 请求参数体
230.      * @param responseType 返回对象类型
231.      * @param uriVariables URL中的变量，按顺序依次对应
232.      * @return ResponseEntity 响应对象封装类
233.      */
234.     public  <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
235.         HttpHeaders httpHeaders = new HttpHeaders();
236.         httpHeaders.setAll(headers);
237.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
238.     }
240.     /**
241.      * 带请求头的POST请求调用方式
242.      *
243.      * @param url 请求URL
244.      * @param headers 请求头参数
245.      * @param requestBody 请求参数体
246.      * @param responseType 返回对象类型
247.      * @param uriVariables URL中的变量，按顺序依次对应
248.      * @return ResponseEntity 响应对象封装类
249.      */
250.     public  <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
251.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
252.         return post(url, requestEntity, responseType, uriVariables);
253.     }
255.     /**
256.      * 带请求头的POST请求调用方式
257.      *
258.      * @param url 请求URL
259.      * @param headers 请求头参数
260.      * @param requestBody 请求参数体
261.      * @param responseType 返回对象类型
262.      * @param uriVariables URL中的变量，与Map中的key对应
263.      * @return ResponseEntity 响应对象封装类
264.      */
265.     public  <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
266.         HttpHeaders httpHeaders = new HttpHeaders();
267.         httpHeaders.setAll(headers);
268.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
269.     }
271.     /**
272.      * 带请求头的POST请求调用方式
273.      *
274.      * @param url 请求URL
275.      * @param headers 请求头参数
276.      * @param requestBody 请求参数体
277.      * @param responseType 返回对象类型
278.      * @param uriVariables URL中的变量，与Map中的key对应
279.      * @return ResponseEntity 响应对象封装类
280.      */
281.     public  <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
282.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
283.         return post(url, requestEntity, responseType, uriVariables);
284.     }
286.     /**
287.      * 自定义请求头和请求体的POST请求调用方式
288.      *
289.      * @param url 请求URL
290.      * @param requestEntity 请求头和请求体封装对象
291.      * @param responseType 返回对象类型
292.      * @param uriVariables URL中的变量，按顺序依次对应
293.      * @return ResponseEntity 响应对象封装类
294.      */
295.     public  <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
296.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
297.     }
299.     /**
300.      * 自定义请求头和请求体的POST请求调用方式
301.      *
302.      * @param url 请求URL
303.      * @param requestEntity 请求头和请求体封装对象
304.      * @param responseType 返回对象类型
305.      * @param uriVariables URL中的变量，与Map中的key对应
306.      * @return ResponseEntity 响应对象封装类
307.      */
308.     public  <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
309.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
310.     }
312.     // ----------------------------------PUT-------------------------------------------------------
314.     /**
315.      * PUT请求调用方式
316.      *
317.      * @param url 请求URL
318.      * @param responseType 返回对象类型
319.      * @param uriVariables URL中的变量，按顺序依次对应
320.      * @return ResponseEntity 响应对象封装类
321.      */
322.     public  <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
323.         return put(url, HttpEntity.EMPTY, responseType, uriVariables);
324.     }
326.     /**
327.      * PUT请求调用方式
328.      *
329.      * @param url 请求URL
330.      * @param requestBody 请求参数体
331.      * @param responseType 返回对象类型
332.      * @param uriVariables URL中的变量，按顺序依次对应
333.      * @return ResponseEntity 响应对象封装类
334.      */
335.     public  <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
336.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
337.         return put(url, requestEntity, responseType, uriVariables);
338.     }
340.     /**
341.      * PUT请求调用方式
342.      *
343.      * @param url 请求URL
344.      * @param requestBody 请求参数体
345.      * @param responseType 返回对象类型
346.      * @param uriVariables URL中的变量，与Map中的key对应
347.      * @return ResponseEntity 响应对象封装类
348.      */
349.     public  <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
350.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
351.         return put(url, requestEntity, responseType, uriVariables);
352.     }
354.     /**
355.      * 带请求头的PUT请求调用方式
356.      *
357.      * @param url 请求URL
358.      * @param headers 请求头参数
359.      * @param requestBody 请求参数体
360.      * @param responseType 返回对象类型
361.      * @param uriVariables URL中的变量，按顺序依次对应
362.      * @return ResponseEntity 响应对象封装类
363.      */
364.     public  <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
365.         HttpHeaders httpHeaders = new HttpHeaders();
366.         httpHeaders.setAll(headers);
367.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
368.     }
370.     /**
371.      * 带请求头的PUT请求调用方式
372.      *
373.      * @param url 请求URL
374.      * @param headers 请求头参数
375.      * @param requestBody 请求参数体
376.      * @param responseType 返回对象类型
377.      * @param uriVariables URL中的变量，按顺序依次对应
378.      * @return ResponseEntity 响应对象封装类
379.      */
380.     public  <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
381.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
382.         return put(url, requestEntity, responseType, uriVariables);
383.     }
385.     /**
386.      * 带请求头的PUT请求调用方式
387.      *
388.      * @param url 请求URL
389.      * @param headers 请求头参数
390.      * @param requestBody 请求参数体
391.      * @param responseType 返回对象类型
392.      * @param uriVariables URL中的变量，与Map中的key对应
393.      * @return ResponseEntity 响应对象封装类
394.      */
395.     public  <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
396.         HttpHeaders httpHeaders = new HttpHeaders();
397.         httpHeaders.setAll(headers);
398.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
399.     }
401.     /**
402.      * 带请求头的PUT请求调用方式
403.      *
404.      * @param url 请求URL
405.      * @param headers 请求头参数
406.      * @param requestBody 请求参数体
407.      * @param responseType 返回对象类型
408.      * @param uriVariables URL中的变量，与Map中的key对应
409.      * @return ResponseEntity 响应对象封装类
410.      */
411.     public  <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
412.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
413.         return put(url, requestEntity, responseType, uriVariables);
414.     }
416.     /**
417.      * 自定义请求头和请求体的PUT请求调用方式
418.      *
419.      * @param url 请求URL
420.      * @param requestEntity 请求头和请求体封装对象
421.      * @param responseType 返回对象类型
422.      * @param uriVariables URL中的变量，按顺序依次对应
423.      * @return ResponseEntity 响应对象封装类
424.      */
425.     public  <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
426.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
427.     }
429.     /**
430.      * 自定义请求头和请求体的PUT请求调用方式
431.      *
432.      * @param url 请求URL
433.      * @param requestEntity 请求头和请求体封装对象
434.      * @param responseType 返回对象类型
435.      * @param uriVariables URL中的变量，与Map中的key对应
436.      * @return ResponseEntity 响应对象封装类
437.      */
438.     public  <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
439.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
440.     }
442.     // ----------------------------------DELETE-------------------------------------------------------
444.     /**
445.      * DELETE请求调用方式
446.      *
447.      * @param url 请求URL
448.      * @param responseType 返回对象类型
449.      * @param uriVariables URL中的变量，按顺序依次对应
450.      * @return ResponseEntity 响应对象封装类
451.      */
452.     public  <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
453.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
454.     }
456.     /**
457.      * DELETE请求调用方式
458.      *
459.      * @param url 请求URL
460.      * @param responseType 返回对象类型
461.      * @param uriVariables URL中的变量，与Map中的key对应
462.      * @return ResponseEntity 响应对象封装类
463.      */
464.     public  <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
465.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
466.     }
468.     /**
469.      * DELETE请求调用方式
470.      *
471.      * @param url 请求URL
472.      * @param requestBody 请求参数体
473.      * @param responseType 返回对象类型
474.      * @param uriVariables URL中的变量，按顺序依次对应
475.      * @return ResponseEntity 响应对象封装类
476.      */
477.     public  <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
478.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
479.         return delete(url, requestEntity, responseType, uriVariables);
480.     }
482.     /**
483.      * DELETE请求调用方式
484.      *
485.      * @param url 请求URL
486.      * @param requestBody 请求参数体
487.      * @param responseType 返回对象类型
488.      * @param uriVariables URL中的变量，与Map中的key对应
489.      * @return ResponseEntity 响应对象封装类
490.      */
491.     public  <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
492.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
493.         return delete(url, requestEntity, responseType, uriVariables);
494.     }
496.     /**
497.      * 带请求头的DELETE请求调用方式
498.      *
499.      * @param url 请求URL
500.      * @param headers 请求头参数
501.      * @param responseType 返回对象类型
502.      * @param uriVariables URL中的变量，按顺序依次对应
503.      * @return ResponseEntity 响应对象封装类
504.      */
505.     public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
506.         HttpHeaders httpHeaders = new HttpHeaders();
507.         httpHeaders.setAll(headers);
508.         return delete(url, httpHeaders, responseType, uriVariables);
509.     }
511.     /**
512.      * 带请求头的DELETE请求调用方式
513.      *
514.      * @param url 请求URL
515.      * @param headers 请求头参数
516.      * @param responseType 返回对象类型
517.      * @param uriVariables URL中的变量，按顺序依次对应
518.      * @return ResponseEntity 响应对象封装类
519.      */
520.     public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
521.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
522.         return delete(url, requestEntity, responseType, uriVariables);
523.     }
525.     /**
526.      * 带请求头的DELETE请求调用方式
527.      *
528.      * @param url 请求URL
529.      * @param headers 请求头参数
530.      * @param responseType 返回对象类型
531.      * @param uriVariables URL中的变量，与Map中的key对应
532.      * @return ResponseEntity 响应对象封装类
533.      */
534.     public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
535.         HttpHeaders httpHeaders = new HttpHeaders();
536.         httpHeaders.setAll(headers);
537.         return delete(url, httpHeaders, responseType, uriVariables);
538.     }
540.     /**
541.      * 带请求头的DELETE请求调用方式
542.      *
543.      * @param url 请求URL
544.      * @param headers 请求头参数
545.      * @param responseType 返回对象类型
546.      * @param uriVariables URL中的变量，与Map中的key对应
547.      * @return ResponseEntity 响应对象封装类
548.      */
549.     public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
550.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
551.         return delete(url, requestEntity, responseType, uriVariables);
552.     }
554.     /**
555.      * 带请求头的DELETE请求调用方式
556.      *
557.      * @param url 请求URL
558.      * @param headers 请求头参数
559.      * @param requestBody 请求参数体
560.      * @param responseType 返回对象类型
561.      * @param uriVariables URL中的变量，按顺序依次对应
562.      * @return ResponseEntity 响应对象封装类
563.      */
564.     public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
565.         HttpHeaders httpHeaders = new HttpHeaders();
566.         httpHeaders.setAll(headers);
567.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
568.     }
570.     /**
571.      * 带请求头的DELETE请求调用方式
572.      *
573.      * @param url 请求URL
574.      * @param headers 请求头参数
575.      * @param requestBody 请求参数体
576.      * @param responseType 返回对象类型
577.      * @param uriVariables URL中的变量，按顺序依次对应
578.      * @return ResponseEntity 响应对象封装类
579.      */
580.     public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
581.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
582.         return delete(url, requestEntity, responseType, uriVariables);
583.     }
585.     /**
586.      * 带请求头的DELETE请求调用方式
587.      *
588.      * @param url 请求URL
589.      * @param headers 请求头参数
590.      * @param requestBody 请求参数体
591.      * @param responseType 返回对象类型
592.      * @param uriVariables URL中的变量，与Map中的key对应
593.      * @return ResponseEntity 响应对象封装类
594.      */
595.     public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
596.         HttpHeaders httpHeaders = new HttpHeaders();
597.         httpHeaders.setAll(headers);
598.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
599.     }
601.     /**
602.      * 带请求头的DELETE请求调用方式
603.      *
604.      * @param url 请求URL
605.      * @param headers 请求头参数
606.      * @param requestBody 请求参数体
607.      * @param responseType 返回对象类型
608.      * @param uriVariables URL中的变量，与Map中的key对应
609.      * @return ResponseEntity 响应对象封装类
610.      */
611.     public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
612.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
613.         return delete(url, requestEntity, responseType, uriVariables);
614.     }
616.     /**
617.      * 自定义请求头和请求体的DELETE请求调用方式
618.      *
619.      * @param url 请求URL
620.      * @param requestEntity 请求头和请求体封装对象
621.      * @param responseType 返回对象类型
622.      * @param uriVariables URL中的变量，按顺序依次对应
623.      * @return ResponseEntity 响应对象封装类
624.      */
625.     public  <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
626.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
627.     }
629.     /**
630.      * 自定义请求头和请求体的DELETE请求调用方式
631.      *
632.      * @param url 请求URL
633.      * @param requestEntity 请求头和请求体封装对象
634.      * @param responseType 返回对象类型
635.      * @param uriVariables URL中的变量，与Map中的key对应
636.      * @return ResponseEntity 响应对象封装类
637.      */
638.     public  <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
639.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
640.     }
642.     // ----------------------------------通用方法-------------------------------------------------------
644.     /**
645.      * 通用调用方式
646.      *
647.      * @param url 请求URL
648.      * @param method 请求方法类型
649.      * @param requestEntity 请求头和请求体封装对象
650.      * @param responseType 返回对象类型
651.      * @param uriVariables URL中的变量，按顺序依次对应
652.      * @return ResponseEntity 响应对象封装类
653.      */
654.     public  <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
655.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
656.     }
658.     /**
659.      * 通用调用方式
660.      *
661.      * @param url 请求URL
662.      * @param method 请求方法类型
663.      * @param requestEntity 请求头和请求体封装对象
664.      * @param responseType 返回对象类型
665.      * @param uriVariables URL中的变量，与Map中的key对应
666.      * @return ResponseEntity 响应对象封装类
667.      */
668.     public  <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
669.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
670.     }
671. }

复制代码

RestTemplate配置类和工具类

RestTemplate配置类

1. @Configuration
2. public class RestTemplateConfig {
3.   @Bean
4.   public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
5.     RestTemplate build = restTemplateBuilder
6.         .requestFactory(OkHttp3ClientHttpRequestFactory.class)
7.         .setConnectTimeout(Duration.ofSeconds(10))
8.         .setReadTimeout(Duration.ofSeconds(20))
9.         .build();
10.     build.getMessageConverters().add(new TextJsonSupport(Jackson2ObjectMapperBuilder.json().build()));
11.     return build;
12.   }
13. }
14. public class TextJsonSupport extends MappingJackson2HttpMessageConverter {
15.   public TextJsonSupport(ObjectMapper objectMapper) {
16.     super(objectMapper);
17.     setSupportedMediaTypes(Arrays.asList(new MediaType("text", "json")));
18.   }
20.   public TextJsonSupport() {
21.     super();
22.   }
23. }

复制代码

RestTemplate工具类

1. public class RestTemplateUtil {
2.   public static Object doGet(String url, HttpHeaders httpHeaders) {
3.     RestTemplate restTemplate = new RestTemplate();
4.     HttpEntity<Object> request = new HttpEntity<>(httpHeaders);
5.     ResponseEntity<Object> result = restTemplate.exchange(url, HttpMethod.GET, request, Object.class);
6.     if (null != result && null != result.getBody()) {
7.       return result.getBody();
8.     }
9.     return null;
10.   }
12.   public static Object doPost(String url, HttpHeaders httpHeaders, JSONObject params) {
13.     RestTemplate restTemplate = new RestTemplate();
14.     HttpEntity<Object> request = new HttpEntity<>(params, httpHeaders);
15.     ResponseEntity<Object> result = restTemplate.exchange(url, HttpMethod.POST, request, Object.class);
16.     if (null != result && null != result.getBody()) {
17.       return result.getBody();
18.     }
19.     return null;
20.   }
22.   public static Object doPostJson(String url, HttpHeaders httpHeaders, JSONObject params) {
23.     RestTemplate restTemplate = new RestTemplate();
24.     HttpEntity<Object> request = new HttpEntity<>(params, httpHeaders);
25.     ResponseEntity<JSONObject> result = restTemplate.exchange(url, HttpMethod.POST, request, JSONObject.class);
26.     if (null != result && null != result.getBody()) {
27.       return result.getBody();
28.     }
29.     return null;
30.   }
31. }

复制代码

以上为个人经验，希望能给大家一个参考，也希望大家多多支持中国红客联盟。