diff --git a/pqs-auth/src/test/java/AuthTest.java b/pqs-auth/src/test/java/AuthTest.java
new file mode 100644
index 000000000..4cfa6bd95
--- /dev/null
+++ b/pqs-auth/src/test/java/AuthTest.java
@@ -0,0 +1,43 @@
+import com.njcn.web.utils.RestTemplateUtil;
+import lombok.SneakyThrows;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.oauth2.common.OAuth2AccessToken;
+import org.springframework.security.oauth2.provider.endpoint.TokenEndpoint;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import java.net.URI;
+
+/**
+ * @author hongawen
+ * @version 1.0.0
+ * @date 2021年12月14日 12:55
+ */
+public class AuthTest extends BaseJunitTest {
+
+
+    @Autowired
+    private TokenEndpoint tokenEndpoint;
+
+
+    @SneakyThrows
+    @Test
+    public void test(){
+//        tokenEndpoint. &client_id=njcn&client_secret=njcnpqs  oAuth2AccessToken
+        System.out.println("hello");
+        String userUrl = "http://127.0.0.1:10214/oauth/token";
+        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(userUrl)
+                .queryParam("grant_type", "password")
+                .queryParam("client_id", "njcn")
+                .queryParam("client_secret", "njcnpqs")
+                .queryParam("username", "root")
+                .queryParam("password", "@#001njcnpqs");
+        URI uri = builder.build().encode().toUri();
+        ResponseEntity<OAuth2AccessToken> userEntity = RestTemplateUtil.post(uri, OAuth2AccessToken.class);
+
+        System.out.println(1);
+
+    }
+
+}
diff --git a/pqs-auth/src/test/java/BaseJunitTest.java b/pqs-auth/src/test/java/BaseJunitTest.java
new file mode 100644
index 000000000..73edfdf53
--- /dev/null
+++ b/pqs-auth/src/test/java/BaseJunitTest.java
@@ -0,0 +1,16 @@
+import com.njcn.auth.AuthApplication;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+
+/**
+ * @author hongawen
+ * @version 1.0.0
+ * @date 2021年12月10日 15:05
+ */
+@RunWith(SpringRunner.class)
+@WebAppConfiguration
+@SpringBootTest(classes = AuthApplication.class)
+public class BaseJunitTest {
+}
diff --git a/pqs-common/common-web/src/main/java/com/njcn/web/utils/RestTemplateUtil.java b/pqs-common/common-web/src/main/java/com/njcn/web/utils/RestTemplateUtil.java
new file mode 100644
index 000000000..527c31bc8
--- /dev/null
+++ b/pqs-common/common-web/src/main/java/com/njcn/web/utils/RestTemplateUtil.java
@@ -0,0 +1,636 @@
+package com.njcn.web.utils;
+
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import java.net.URI;
+import java.util.Map;
+
+/**
+ * @author hongawen
+ * package javax.utils;
+ * @createDate 2019-02-08
+ *
+ */
+public class RestTemplateUtil {
+
+    private static final RestTemplate restTemplate = new RestTemplate();
+
+    // ----------------------------------GET-------------------------------------------------------
+
+    /**
+     * GET请求调用方式
+     *
+     * @param url 请求URL
+     * @param responseType 返回对象类型
+     * @return ResponseEntity 响应对象封装类
+     */
+    public static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <T> ResponseEntity<T> post(String url, Class<T> responseType) {
+        return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
+    }
+
+    /**
+     * POST请求调用方式
+     *
+     * @param uri 请求URL
+     * @param responseType 返回对象类型
+     */
+    public static <T> ResponseEntity<T> post(URI uri, Class<T> responseType) {
+        return restTemplate.exchange(uri,HttpMethod.POST, HttpEntity.EMPTY, responseType);
+    }
+
+    /**
+     * POST请求调用方式
+     *
+     * @param url 请求URL
+     * @param requestBody 请求参数体
+     * @param responseType 返回对象类型
+     * @return ResponseEntity 响应对象封装类
+     */
+    public static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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实例对象，可自由调用其方法
+     *
+     * @return RestTemplate实例对象
+     */
+    public static RestTemplate getRestTemplate() {
+        return restTemplate;
+    }
+
+
+}
\ No newline at end of file