第一步：创建待测试的项目
添加Maven依赖
org.projectlombok
lombok
1.18.12
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-thymeleaf
com.fasterxml.jackson.core
jackson-databind
server:
port: 80
servlet:
context-path: /trtd
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
private int deptno;
private String dname;
private String loc;
}
@Controller
@RequestMapping("/dept3")
public class DeptController3 {
@ResponseBody
@GetMapping("/demo11")
public Dept demo11() {
Dept dept = new Dept(10, "aa", "aaaaaaaa");
return dept;
}
@ResponseBody
@GetMapping("/demo12")
public Dept demo12(String dname, String loc) {
Dept dept = new Dept();
dept.setDeptno(new Random().nextInt());
dept.setDname(dname);
dept.setLoc(loc);
return dept;
}
@ResponseBody
@GetMapping("/demo13")
public Dept demo13(@RequestParam("deptno") Integer deptno, String dname, String loc) {
Dept dept = new Dept();
dept.setDeptno(deptno);
dept.setDname(dname);
dept.setLoc(loc);
return dept;
}
/
@ResponseBody
@PostMapping("/demo21")
public Dept demo21() {
Dept dept = new Dept(10, "aa", "aaaaaaaa");
return dept;
}
@ResponseBody
@PostMapping("/demo22")
public Dept demo22(String dname, String loc) {
Dept dept = new Dept();
dept.setDeptno(new Random().nextInt());
dept.setDname(dname);
dept.setLoc(loc);
return dept;
}
@ResponseBody
@PostMapping("/demo23")
public Dept demo23(@RequestParam("query")String query, @RequestParam("deptno") Integer deptno, String dname, String loc) {
System.out.println(query);
Dept dept = new Dept();
dept.setDeptno(deptno);
dept.setDname(dname);
dept.setLoc(loc);
return dept;
}
}
org.projectlombok
lombok
1.18.12
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-thymeleaf
com.fasterxml.jackson.core
jackson-databind
/**
* RestTemplate 远程调用工具类
*/
public class RestTemplateUtils {
private static final RestTemplate restTemplate = new RestTemplate();
// ----------------------------------GET-------------------------------------------------------
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, Class responseType) {
return restTemplate.getForEntity(url, responseType);
}
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, Class responseType, Object... params) {
return restTemplate.getForEntity(url, responseType, params);
}
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, Class responseType, Map params) {
return restTemplate.getForEntity(url, responseType, params);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, Map headers, Class responseType, Object... params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return get(url, httpHeaders, responseType, params);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, HttpHeaders headers, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(headers);
return exchange(url, HttpMethod.GET, requestEntity, responseType, params);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, Map headers, Class responseType, Map params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return get(url, httpHeaders, responseType, params);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity get(String url, HttpHeaders headers, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(headers);
return exchange(url, HttpMethod.GET, requestEntity, responseType, params);
}
// ----------------------------------POST-------------------------------------------------------
/**
* POST请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @return
*/
public static ResponseEntity post(String url, Class responseType) {
return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, Object requestBody, Class responseType) {
return restTemplate.postForEntity(url, requestBody, responseType);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, Object requestBody, Class responseType, Object... params) {
return restTemplate.postForEntity(url, requestBody, responseType, params);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, Object requestBody, Class responseType, Map params) {
return restTemplate.postForEntity(url, requestBody, responseType, params);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, Map headers, Object requestBody, Class responseType, Object... params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return post(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, HttpHeaders headers, Object requestBody, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return post(url, requestEntity, responseType, params);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, Map headers, Object requestBody, Class responseType, Map params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return post(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, HttpHeaders headers, Object requestBody, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return post(url, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的POST请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, HttpEntity requestEntity, Class responseType, Object... params) {
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的POST请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity post(String url, HttpEntity requestEntity, Class responseType, Map params) {
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, params);
}
// ----------------------------------PUT-------------------------------------------------------
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, Class responseType, Object... params) {
return put(url, HttpEntity.EMPTY, responseType, params);
}
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, Object requestBody, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(requestBody);
return put(url, requestEntity, responseType, params);
}
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, Object requestBody, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(requestBody);
return put(url, requestEntity, responseType, params);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, Map headers, Object requestBody, Class responseType, Object... params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return put(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, HttpHeaders headers, Object requestBody, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return put(url, requestEntity, responseType, params);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, Map headers, Object requestBody, Class responseType, Map params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return put(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, HttpHeaders headers, Object requestBody, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return put(url, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的PUT请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, HttpEntity requestEntity, Class responseType, Object... params) {
return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的PUT请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity put(String url, HttpEntity requestEntity, Class responseType, Map params) {
return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, params);
}
// ----------------------------------DELETE-------------------------------------------------------
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Class responseType, Object... params) {
return delete(url, HttpEntity.EMPTY, responseType, params);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Class responseType, Map params) {
return delete(url, HttpEntity.EMPTY, responseType, params);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Object requestBody, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(requestBody);
return delete(url, requestEntity, responseType, params);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Object requestBody, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(requestBody);
return delete(url, requestEntity, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Map headers, Class responseType, Object... params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpHeaders headers, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(headers);
return delete(url, requestEntity, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Map headers, Class responseType, Map params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpHeaders headers, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(headers);
return delete(url, requestEntity, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Map headers, Object requestBody, Class responseType, Object... params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpHeaders headers, Object requestBody, Class responseType, Object... params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return delete(url, requestEntity, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, Map headers, Object requestBody, Class responseType, Map params) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, requestBody, responseType, params);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpHeaders headers, Object requestBody, Class responseType, Map params) {
HttpEntity requestEntity = new HttpEntity(requestBody, headers);
return delete(url, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的DELETE请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpEntity requestEntity, Class responseType, Object... params) {
return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, params);
}
/**
* 自定义请求头和请求体的DELETE请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity delete(String url, HttpEntity requestEntity, Class responseType, Map params) {
return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, params);
}
// ----------------------------------通用方法-------------------------------------------------------
/**
* 通用调用方式
*
* @param url 请求URL
* @param method 请求方法类型
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity exchange(String url, HttpMethod method, HttpEntity requestEntity, Class responseType, Object... params) {
return restTemplate.exchange(url, method, requestEntity, responseType, params);
}
/**
* 通用调用方式
*
* @param url 请求URL
* @param method 请求方法类型
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param params URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static ResponseEntity exchange(String url, HttpMethod method, HttpEntity requestEntity, Class responseType, Map params) {
return restTemplate.exchange(url, method, requestEntity, responseType, params);
}
/**
* 获取RestTemplate实例对象，可自由调用其方法
*
* @return RestTemplate实例对象
*/
public static RestTemplate getRestTemplate() {
return restTemplate;
}
}
/**
* RestTemplate 功能测试类
*
* 需要先启动部署项目，再进行测试
*/
public class RestTemplateUtilsTest {
private String baseUrl = "http://localhost:80/trtd/dept3/";
@Test
public void get11() {
ResponseEntity res = RestTemplateUtils.get(baseUrl + "demo11", String.class);
System.out.println(res);
}
@Test
public void get12() {
ResponseEntity res = RestTemplateUtils.get(baseUrl + "demo12?dname={dname}&loc={loc}", String.class, "sales", "NewYork");
System.out.println(res);
}
@Test
public void post13() {
Map map = new HashMap();
map.put("no", 33);
map.put("name", "haha");
map.put("loc", "hahahahahaha");
ResponseEntity res = RestTemplateUtils.get(baseUrl + "demo13?deptno={no}&dname={name}&loc={loc}", String.class, map);
System.out.println(res);
}
@Test
public void post21() {
ResponseEntity res = RestTemplateUtils.post(baseUrl + "demo21", String.class);
System.out.println(res);
}
@Test
public void post22() {
MultiValueMap multiValueMap = new LinkedMultiValueMap();
multiValueMap.set("dname", "sales");
multiValueMap.set("loc", "china");
ResponseEntity res = RestTemplateUtils.post(baseUrl + "demo22", multiValueMap, String.class);
System.out.println(res);
}
@Test
public void post231() {
MultiValueMap multiValueMap = new LinkedMultiValueMap();
multiValueMap.set("dname", "sales");
multiValueMap.set("loc", "china");
ResponseEntity res = RestTemplateUtils.post(baseUrl + "demo23?query={0}&deptno={1}", multiValueMap, String.class, "fdsfsdf", 55);
System.out.println(res);
}
@Test
public void post232() {
MultiValueMap multiValueMap = new LinkedMultiValueMap();
multiValueMap.set("dname", "sales");
multiValueMap.set("loc", "china");
Map map = new HashMap();
map.put("q", "haha");
map.put("no", 99);
ResponseEntity res = RestTemplateUtils.post(baseUrl + "demo23?query={q}&deptno={no}", multiValueMap, String.class, map);
System.out.println(res);
}
}
