摘要：
Spring远程调用Rest服务工具类，包含Get、Post、Put、Delete四种调用方式。˃uriVariables){returnrestTemplate.getForEntity;}/***带请求头的GET请求调用方式**@paramurl请求URL*@paramheaders请求头参数*@paramresponseType返回对象类型*@paramuriVariablesURL中的变量，按顺序依次对应*@returnResponseEntity响应对象封装类*/publicstaticResponseEntityget{HttpHeadershttpHeaders=newHttpHeaders();httpHeaders.setAll;returnget;}/***带请求头的GET请求调用方式**@paramurl请求URL*@paramheaders请求头参数*@paramresponseType返回对象类型*@paramuriVariablesURL中的变量，按顺序依次对应*@returnResponseEntity响应对象封装类*/publicstaticResponseEntityget{HttpEntity˂?
Spring 远程调用Rest服务工具类，包含Get、Post、Put、Delete四种调用方式。
依赖jar
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.9.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.0.9.RELEASE</version> </dependency>
RestTemplateUtils.java
packagejavax.utils; importjava.util.Map; importorg.springframework.http.HttpEntity; importorg.springframework.http.HttpHeaders; importorg.springframework.http.HttpMethod; importorg.springframework.http.ResponseEntity; importorg.springframework.web.client.RestTemplate; /** * RestTemplate 远程调用工具类 * * @authorLogan * @createDate 2019-02-08 * */ public classRestTemplateUtils { private static final RestTemplate restTemplate = newRestTemplate(); //----------------------------------GET------------------------------------------------------- /** * GET请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, Class<T>responseType) { returnrestTemplate.getForEntity(url, responseType); } /** * GET请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, Class<T>responseType, Object... uriVariables) { returnrestTemplate.getForEntity(url, responseType, uriVariables); } /** * GET请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.getForEntity(url, responseType, uriVariables); } /** * 带请求头的GET请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T>responseType, Object... uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnget(url, httpHeaders, responseType, uriVariables); } /** * 带请求头的GET请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T>responseType, Object... uriVariables) { HttpEntity<?> requestEntity = new HttpEntity<>(headers); returnexchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables); } /** * 带请求头的GET请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?>uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnget(url, httpHeaders, responseType, uriVariables); } /** * 带请求头的GET请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?>uriVariables) { HttpEntity<?> requestEntity = new HttpEntity<>(headers); returnexchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables); } //----------------------------------POST------------------------------------------------------- /** * POST请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @return */ public static <T> ResponseEntity<T> post(String url, Class<T>responseType) { returnrestTemplate.postForEntity(url, HttpEntity.EMPTY, responseType); } /** * POST请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T>responseType) { returnrestTemplate.postForEntity(url, requestBody, responseType); } /** * POST请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T>responseType, Object... uriVariables) { returnrestTemplate.postForEntity(url, requestBody, responseType, uriVariables); } /** * POST请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.postForEntity(url, requestBody, responseType, uriVariables); } /** * 带请求头的POST请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T>responseType, Object... uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnpost(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的POST请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ 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); returnpost(url, requestEntity, responseType, uriVariables); } /** * 带请求头的POST请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnpost(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的POST请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ 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); returnpost(url, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的POST请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T>responseType, Object... uriVariables) { returnrestTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的POST请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables); } //----------------------------------PUT------------------------------------------------------- /** * PUT请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, Class<T>responseType, Object... uriVariables) { returnput(url, HttpEntity.EMPTY, responseType, uriVariables); } /** * PUT请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T>responseType, Object... uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody); returnput(url, requestEntity, responseType, uriVariables); } /** * PUT请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody); returnput(url, requestEntity, responseType, uriVariables); } /** * 带请求头的PUT请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T>responseType, Object... uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnput(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的PUT请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ 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); returnput(url, requestEntity, responseType, uriVariables); } /** * 带请求头的PUT请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returnput(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的PUT请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ 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); returnput(url, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的PUT请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T>responseType, Object... uriVariables) { returnrestTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的PUT请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables); } //----------------------------------DELETE------------------------------------------------------- /** * DELETE请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Class<T>responseType, Object... uriVariables) { returndelete(url, HttpEntity.EMPTY, responseType, uriVariables); } /** * DELETE请求调用方式 * * @paramurl 请求URL * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?>uriVariables) { returndelete(url, HttpEntity.EMPTY, responseType, uriVariables); } /** * DELETE请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T>responseType, Object... uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody); returndelete(url, requestEntity, responseType, uriVariables); } /** * DELETE请求调用方式 * * @paramurl 请求URL * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody); returndelete(url, requestEntity, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T>responseType, Object... uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returndelete(url, httpHeaders, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T>responseType, Object... uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers); returndelete(url, requestEntity, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?>uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returndelete(url, httpHeaders, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?>uriVariables) { HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers); returndelete(url, requestEntity, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T>responseType, Object... uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returndelete(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ 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); returndelete(url, requestEntity, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?>uriVariables) { HttpHeaders httpHeaders = newHttpHeaders(); httpHeaders.setAll(headers); returndelete(url, httpHeaders, requestBody, responseType, uriVariables); } /** * 带请求头的DELETE请求调用方式 * * @paramurl 请求URL * @paramheaders 请求头参数 * @paramrequestBody 请求参数体 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ 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); returndelete(url, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的DELETE请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T>responseType, Object... uriVariables) { returnrestTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables); } /** * 自定义请求头和请求体的DELETE请求调用方式 * * @paramurl 请求URL * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables); } //----------------------------------通用方法------------------------------------------------------- /** * 通用调用方式 * * @paramurl 请求URL * @parammethod 请求方法类型 * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，按顺序依次对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T>responseType, Object... uriVariables) { returnrestTemplate.exchange(url, method, requestEntity, responseType, uriVariables); } /** * 通用调用方式 * * @paramurl 请求URL * @parammethod 请求方法类型 * @paramrequestEntity 请求头和请求体封装对象 * @paramresponseType 返回对象类型 * @paramuriVariables URL中的变量，与Map中的key对应 * @returnResponseEntity 响应对象封装类 */ public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?>uriVariables) { returnrestTemplate.exchange(url, method, requestEntity, responseType, uriVariables); } /** * 获取RestTemplate实例对象，可自由调用其方法 * * @returnRestTemplate实例对象 */ public staticRestTemplate getRestTemplate() { returnrestTemplate; } }
测试示例如下：
RestTest.java
packagetest; importjava.io.File; importjava.io.IOException; importjava.util.ArrayList; importjava.util.HashMap; importjava.util.List; importjava.util.Map; importorg.apache.commons.io.FileUtils; importorg.junit.Test; importorg.springframework.core.io.FileSystemResource; importorg.springframework.http.HttpStatus; importorg.springframework.http.ResponseEntity; importorg.springframework.util.LinkedMultiValueMap; importorg.springframework.util.MultiValueMap; importcom.alibaba.fastjson.JSONObject; importutils.RestTemplateUtils; /** * RestTemplate 功能测试类 * * @authorLogan * @createDate 2019-02-08 * */ public classRestTest { /** * 测试HTTPS请求访问博客园 */ @Test public voidtest() { String url = "https://www.cnblogs.com/{id}/p/{pageName}.html"; String id = "jonban"; List<String> pages = new ArrayList<>(); pages.add("rest"); pages.add("jsoup"); pages.add("sms"); pages.add("rememberMe"); pages.add("properties"); pages.add("async"); for(String pageName : pages) { ResponseEntity<String> entity = RestTemplateUtils.get(url, String.class, id, pageName); System.out.println(entity.getStatusCode()); System.out.println(entity.getBody()); } } /** * 测试带请求头参数Headers的GET请求，POST类似 */ @Test public voidtestHeaders() { String url = "http://127.0.0.1:8080/test/Logan?age=16"; Map<String, String> headers = new HashMap<>(); headers.put("appId", "Basic MyAppId"); ResponseEntity<String> entity = RestTemplateUtils.get(url, headers, String.class); System.out.println(entity.getStatusCode()); System.out.println(entity.getBody()); } /** * 测试普通表单参数的POST请求 */ @Test public voidsayHello() { String url = "http://127.0.0.1:8080/test/sayHello"; MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>(); requestBody.add("name", "Logan"); requestBody.add("age", 12); ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class); System.out.println(response.getStatusCode()); System.out.println(response.getBody()); } /** * 测试JSON格式请求体Body方式POST请求 */ @Test public voidsayHelloBody() { String url = "http://127.0.0.1:8080/test/sayHelloBody"; JSONObject requestBody = newJSONObject(); requestBody.put("name", "Logan"); requestBody.put("age", 16); ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class); System.out.println(response.getStatusCode()); System.out.println(response.getBody()); } /** * 测试上传文件 */ @Test public voiduploadFile() { String url = "http://127.0.0.1:8080/test/uploadFile"; MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>(); requestBody.add("uploadPath", "G:\Temp\Test"); requestBody.add("file", new FileSystemResource("G:\Java\JavaStyle.xml")); requestBody.add("file2", new FileSystemResource("G:\Java\jad.exe")); ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class); System.out.println(response.getStatusCode()); System.out.println(response.getBody()); } @Test public voiddownloadFile() { try{ String url = "http://127.0.0.1:8080/test/downloadFile?filePath={filePath}&fileName={fileName}"; String filePath = "G:\Java"; String fileName = "JavaStyle.xml"; ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class, filePath, fileName); System.out.println(response.getStatusCode()); System.out.println(response.getHeaders().getContentType()); //如果返回时文本内容，则直接输出 if ("text/html;charset=UTF-8".equals(response.getHeaders().getContentType().toString())) { System.out.println(new String(response.getBody(), "UTF-8")); } //输出响应内容到本地文件 else{ File file = new File("G:\Temp\Test", fileName); if(HttpStatus.OK.equals(response.getStatusCode())) { FileUtils.writeByteArrayToFile(file, response.getBody()); } } } catch(IOException e) { e.printStackTrace(); } } /** * 测试下载阿里巴巴的fastjson-1.2.56.jar */ @Test public voiddownloadFile2() { try{ String url = "http://central.maven.org/maven2/com/alibaba/fastjson/1.2.56/fastjson-1.2.56.jar"; ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class); System.out.println(response.getStatusCode()); //下载文件路径，可根据本地磁盘位置选择下载路径 File file = new File("G:\Temp\Test\fastjson-1.2.56.jar"); if(HttpStatus.OK.equals(response.getStatusCode())) { FileUtils.writeByteArrayToFile(file, response.getBody()); } } catch(IOException e) { e.printStackTrace(); } } }
测试远程服务器接口示例如下：
1. 新建Maven项目test-server
2. pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.java</groupId> <artifactId>test-server</artifactId> <version>1.0.0</version> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.5.RELEASE</version> </parent> <dependencies> <!--Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.3</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.56</version> </dependency> <!--热部署 --> <dependency> <groupId>org.springframework</groupId> <artifactId>springloaded</artifactId> <version>1.2.8.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> </dependency> </dependencies> <build> <finalName>${project.artifactId}</finalName> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>
3. TestServerStarter.java
packagecom.java; importorg.springframework.boot.SpringApplication; importorg.springframework.boot.autoconfigure.SpringBootApplication; /** * 测试服务器主启动类 * * @authorLogan * @createDate 2019-02-08 * */ @SpringBootApplication public classTestServerStarter { public static voidmain(String[] args) { SpringApplication.run(TestServerStarter.class, args); } }
4. Person.java
packagecom.java.entity; /** * 测试实体类 * * @authorLogan * @createDate 2019-02-08 * */ public classPerson { privateString name; private intage; publicString getName() { returnname; } public voidsetName(String name) { this.name =name; } public intgetAge() { returnage; } public void setAge(intage) { this.age =age; } @Override publicString toString() { return "Person [name=" + name + ", age=" + age + "]"; } }
5. UploadConfig.java
packagecom.java.config; importorg.springframework.context.annotation.Bean; importorg.springframework.context.annotation.Configuration; importorg.springframework.web.multipart.commons.CommonsMultipartResolver; /** * 上传文件配置 * * @authorLogan * @createDate 2019-02-08 * */ @Configuration public classUploadConfig { @Bean publicCommonsMultipartResolver multipartResolver() { CommonsMultipartResolver multipartResolver = newCommonsMultipartResolver(); //设置最大上传文件大小为4GB multipartResolver.setMaxUploadSize(4294967296l); returnmultipartResolver; } }
6. TestController.java
packagecom.java.controller; importjava.io.File; importjava.io.FileInputStream; importjava.io.FileNotFoundException; importjava.io.IOException; importjava.io.OutputStream; importjava.io.PrintWriter; importjava.net.URLEncoder; importjava.util.ArrayList; importjava.util.HashMap; importjava.util.List; importjava.util.Map; importjavax.servlet.http.HttpServletRequest; importjavax.servlet.http.HttpServletResponse; importorg.apache.commons.io.IOUtils; importorg.springframework.beans.factory.annotation.Autowired; importorg.springframework.web.bind.annotation.GetMapping; importorg.springframework.web.bind.annotation.PathVariable; importorg.springframework.web.bind.annotation.PostMapping; importorg.springframework.web.bind.annotation.RequestBody; importorg.springframework.web.bind.annotation.RequestMapping; importorg.springframework.web.bind.annotation.RequestParam; importorg.springframework.web.bind.annotation.RestController; importorg.springframework.web.multipart.commons.CommonsMultipartFile; importcom.java.entity.Person; /** * 测试服务器测试接口类 * * @authorLogan * @createDate 2019-02-08 * */ @RestController @RequestMapping("/test") public classTestController { @Autowired privateHttpServletRequest request; @GetMapping("/{name}") public Person test(@PathVariable("name") String name, intage) { String appId = request.getHeader("appId"); System.out.println("appId: " +appId); Person person = newPerson(); person.setName(name); person.setAge(age); System.out.println(person); returnperson; } @PostMapping("/sayHello") publicPerson sayHello(Person person) { System.out.println(person); returnperson; } @PostMapping("/sayHelloBody") publicPerson sayHelloBody(@RequestBody Person person) { System.out.println(person); returnperson; } @RequestMapping("/uploadFile") public Map<String, Object> uploadFile(@RequestParam(required = true) CommonsMultipartFile file, @RequestParam(required = true) CommonsMultipartFile file2, String uploadPath) { Map<String, Object> result = new HashMap<String, Object>(); try{ //上傳文件 File path = newFile(uploadPath); if (!path.isDirectory() || !path.exists()) { path.mkdirs(); } File outFile = newFile(uploadPath, file.getOriginalFilename()); file.transferTo(outFile); File outFile2 = newFile(uploadPath, file2.getOriginalFilename()); file2.transferTo(outFile2); List<String> files = new ArrayList<>(); files.add(outFile.getAbsolutePath()); files.add(outFile2.getAbsolutePath()); result.put("successful", true); result.put("files", files); } catch(Exception e) { e.printStackTrace(); result.put("successful", false); result.put("msg", e.getMessage()); } returnresult; } @GetMapping("/downloadFile") public voiddownloadFile(HttpServletResponse response, String filePath, String fileName) { File file = newFile(filePath, fileName); if (file.exists() &&file.isFile()) { try( OutputStream out =response.getOutputStream(); FileInputStream in = newFileInputStream(file); ) { //对文件名进行URL转义，防止中文乱码 fileName = URLEncoder.encode(fileName, "UTF-8"); //空格用URLEncoder.encode转义后会变成"+"，所以要替换成"%20"，浏览器会解码回空格 fileName = fileName.replace("+", "%20"); //"+"用URLEncoder.encode转义后会变成"%2B"，所以要替换成"+"，浏览器会解码回"+" fileName = fileName.replace("%2B", "+"); response.setContentType("application/x-msdownload;charset=UTF-8"); response.setHeader("Content-Disposition", "attachment; filename=" +fileName); IOUtils.copy(in, out); } catch(FileNotFoundException e) { e.printStackTrace(); } catch(IOException e) { e.printStackTrace(); } } //无法下载时给出提示信息 else{ response.setContentType("text/html;charset=UTF-8"); try( PrintWriter writer =response.getWriter(); ) { writer.write("找不到对应文件，请确认后重试！"); writer.flush(); } catch(IOException e) { e.printStackTrace(); } } } }
7. 运行TestServerStarter.java ，启动测试服务器。
运行RestTest.java 类中对应的测试方法，可以测试对应功能，各种情况典型示例已给出。
.