当前位置 : 主页 > 编程语言 > java >

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

来源:互联网 收集:自由互联 发布时间:2023-01-30
目录 工具类-RestTemplateUtil工具类 代码可直接复制使用 RestTemplate配置类和工具类 工具类-RestTemplateUtil工具类 代码可直接复制使用 配置RestTemplate import org.springframework.context.annotation.Bean;i
目录
  • 工具类-RestTemplateUtil工具类
    • 代码可直接复制使用
  • RestTemplate配置类和工具类

    工具类-RestTemplateUtil工具类

    代码可直接复制使用

    配置RestTemplate

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class RestTemplateConfig {
    
        @Bean
        public RestTemplate restTemplate() {
            SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
            requestFactory.setConnectTimeout(60000);
            requestFactory.setReadTimeout(60000);
            //使用okhttp
            //RestTemplate restTemplate = new RestTemplate(new OkHttp3ClientHttpRequestFactory());
            RestTemplate restTemplate = new RestTemplate(requestFactory);
            return restTemplate;
        }
    }

    RestTemplateUtil工具类

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpEntity;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpMethod;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Component;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * RestTemplateUtil工具类
     */
    @Component
    public class RestTemplateUtil {
    
        @Autowired
        private RestTemplate restTemplate;
      /*  private static class SingletonRestTemplate {
    
            static final RestTemplate INSTANCE = new RestTemplate();
        }
    
        private RestTemplateUtil() {
        }
    
    
        public static RestTemplate getInstance() {
            return SingletonRestTemplate.INSTANCE;
        }*/
    
        /**
         * post 请求
         *
         * @param url  请求路径
         * @param data body数据
         * @return
         */
        public String post(String url, String data) {
            HttpHeaders headers = new HttpHeaders();
            headers.add("Accept", "application/json");
            headers.add("Content-Encoding", "UTF-8");
            headers.add("Content-Type", "application/json; charset=UTF-8");
            HttpEntity<String> requestEntity = new HttpEntity<>(data, headers);
            return restTemplate.postForObject(url, requestEntity, String.class);
        }
    
        /**
         * get 请求
         *
         * @param url   请求路径
         * @param token JWT所需的Token,不需要的可去掉
         * @return
         */
        public String get(String url, String token) {
            HttpHeaders headers = new HttpHeaders();
            headers.add("Accept", "application/json");
            headers.add("Content-Encoding", "UTF-8");
            headers.add("Content-Type", "application/json; charset=UTF-8");
            if (token != null) {
                headers.add("Authorization", token);
            }
            HttpEntity<String> requestEntity = new HttpEntity<>(null, headers);
            ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
            String responseBody = response.getBody();
            return responseBody;
        }
     /**
         * get 请求
         *
         * @param url   请求路径
         * @return
         */
    
        public  <T> T getWithSession(String url, String sessionId, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.add("session_id", sessionId);
            return get(url, httpHeaders, responseType, uriVariables).getBody();
        }
    
        // ----------------------------------GET-------------------------------------------------------
    
        /**
         * GET请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, Class<T> responseType) {
            return restTemplate.getForEntity(url, responseType);
        }
    
        /**
         * GET请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
            return restTemplate.getForEntity(url, responseType, uriVariables);
        }
    
        /**
         * GET请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.getForEntity(url, responseType, uriVariables);
        }
    
        /**
         * 带请求头的GET请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return get(url, httpHeaders, responseType, uriVariables);
        }
    
        /**
         * 带请求头的GET请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
            HttpEntity<?> requestEntity = new HttpEntity<>(headers);
            return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的GET请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return get(url, httpHeaders, responseType, uriVariables);
        }
    
        /**
         * 带请求头的GET请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<?> requestEntity = new HttpEntity<>(headers);
            return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
        }
    
        // ----------------------------------POST-------------------------------------------------------
    
        /**
         * POST请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @return
         */
        public  <T> ResponseEntity<T> post(String url, Class<T> responseType) {
            return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
        }
    
        /**
         * POST请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
            return restTemplate.postForEntity(url, requestBody, responseType);
        }
    
        /**
         * POST请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
            return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
        }
    
        /**
         * POST请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的POST请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return post(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的POST请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return post(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的POST请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return post(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的POST请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return post(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的POST请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
            return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的POST请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
        }
    
        // ----------------------------------PUT-------------------------------------------------------
    
        /**
         * PUT请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
            return put(url, HttpEntity.EMPTY, responseType, uriVariables);
        }
    
        /**
         * PUT请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
            return put(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * PUT请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
            return put(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的PUT请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return put(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的PUT请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return put(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的PUT请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return put(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的PUT请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return put(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的PUT请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
            return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的PUT请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
        }
    
        // ----------------------------------DELETE-------------------------------------------------------
    
        /**
         * DELETE请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
            return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
        }
    
        /**
         * DELETE请求调用方式
         *
         * @param url 请求URL
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
            return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
        }
    
        /**
         * DELETE请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * DELETE请求调用方式
         *
         * @param url 请求URL
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return delete(url, httpHeaders, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return delete(url, httpHeaders, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return delete(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setAll(headers);
            return delete(url, httpHeaders, requestBody, responseType, uriVariables);
        }
    
        /**
         * 带请求头的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param headers 请求头参数
         * @param requestBody 请求参数体
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
            HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
            return delete(url, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
            return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 自定义请求头和请求体的DELETE请求调用方式
         *
         * @param url 请求URL
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
        }
    
        // ----------------------------------通用方法-------------------------------------------------------
    
        /**
         * 通用调用方式
         *
         * @param url 请求URL
         * @param method 请求方法类型
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,按顺序依次对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
            return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
        }
    
        /**
         * 通用调用方式
         *
         * @param url 请求URL
         * @param method 请求方法类型
         * @param requestEntity 请求头和请求体封装对象
         * @param responseType 返回对象类型
         * @param uriVariables URL中的变量,与Map中的key对应
         * @return ResponseEntity 响应对象封装类
         */
        public  <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
            return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
        }
    }

    RestTemplate配置类和工具类

    RestTemplate配置类

    @Configuration
    public class RestTemplateConfig {
        @Bean
        public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
            RestTemplate build = restTemplateBuilder
                    .requestFactory(OkHttp3ClientHttpRequestFactory.class)
                    .setConnectTimeout(Duration.ofSeconds(10))
                    .setReadTimeout(Duration.ofSeconds(20))
                    .build();
            build.getMessageConverters().add(new TextJsonSupport(Jackson2ObjectMapperBuilder.json().build()));
            return build;
        }
    }
    public class TextJsonSupport extends MappingJackson2HttpMessageConverter {
        public TextJsonSupport(ObjectMapper objectMapper) {
            super(objectMapper);
            setSupportedMediaTypes(Arrays.asList(new MediaType("text", "json")));
        }
     
        public TextJsonSupport() {
            super();
        }
    }

    RestTemplate工具类

    public class RestTemplateUtil {
        public static Object doGet(String url, HttpHeaders httpHeaders) {
            RestTemplate restTemplate = new RestTemplate();
            HttpEntity<Object> request = new HttpEntity<>(httpHeaders);
            ResponseEntity<Object> result = restTemplate.exchange(url, HttpMethod.GET, request, Object.class);
            if (null != result && null != result.getBody()) {
                return result.getBody();
            }
            return null;
        }
     
        public static Object doPost(String url, HttpHeaders httpHeaders, JSONObject params) {
            RestTemplate restTemplate = new RestTemplate();
            HttpEntity<Object> request = new HttpEntity<>(params, httpHeaders);
            ResponseEntity<Object> result = restTemplate.exchange(url, HttpMethod.POST, request, Object.class);
            if (null != result && null != result.getBody()) {
                return result.getBody();
            }
            return null;
        }
     
        public static Object doPostJson(String url, HttpHeaders httpHeaders, JSONObject params) {
            RestTemplate restTemplate = new RestTemplate();
            HttpEntity<Object> request = new HttpEntity<>(params, httpHeaders);
            ResponseEntity<JSONObject> result = restTemplate.exchange(url, HttpMethod.POST, request, JSONObject.class);
            if (null != result && null != result.getBody()) {
                return result.getBody();
            }
            return null;
        }
    }

    以上为个人经验,希望能给大家一个参考,也希望大家多多支持自由互联。

    上一篇:Java之CountDownLatch原理全面解析
    下一篇:没有了
    网友评论