spring boot（八）使用RestTemplate操作

版权声明：菜鸟_zhengke的博客 https://blog.csdn.net/qq_42014192/article/details/89466636

介绍之前先了解一下restful编程风格

https://blog.csdn.net/qq_42014192/article/details/86540859

1.新建一个springboot项目

https://blog.csdn.net/qq_42014192/article/details/88742559

2.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot_rest_template_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_rest_template_demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

        <!--<dependency> -->
            <!--<groupId> org.springframework.boot </ groupId> -->
            <!--<artifactId> spring-boot-devtools </ artifactId> -->
            <!--<optional> true </ optional> -->
        <!--</ dependency>-->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.启动类

@SpringBootApplication
public class SpringbootRestTemplateDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootRestTemplateDemoApplication.class, args);
    }

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
        return new RestTemplate(factory);
    }

    /**
     * 工厂
     * @return
     */
    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setReadTimeout(5000);
        factory.setConnectTimeout(5000);
        return factory;
    }
}

4.创建一个控制类ControllerTest方法接口

@RestController
public class ControllerTest {
    /**
     * http://localhost:8080/get?name=zhengke
     * @param name
     * @param request
     * @return
     */
    @GetMapping("/get")
    public String get(@RequestParam(value = "name", defaultValue = "forezp") String name, HttpServletRequest request){
        String method = request.getMethod();
        return "Controller " + name + " method " + method;
    }
    /**
     * http://localhost:8080/post
     * @param name zhengke
     * @param request
     * @return
     */
    @PostMapping("/post")
    public String post(@RequestBody String name ,HttpServletRequest request){
        String method = request.getMethod();
        return "Controller " + name + " method " + method;
    }
    /**
     * http://localhost:8080/put
     * @param name zhengke
     * @param request
     * @return
     */
    @PutMapping("/put")
    public void put(@RequestBody String name,HttpServletRequest request){
        String method = request.getMethod();
        System.out.println("Controller " + name + " method " + method);
    }

    /**
     * http://localhost:8080/delete
     * @param name
     * @param request
     */
    @DeleteMapping("/delete")
    public String delete(@RequestParam(value = "name", defaultValue = "forezp") String name,HttpServletRequest request){
        String method = request.getMethod();
        System.out.println("Controller " + name + " method " + method);
        return "Controller " + name + " method " + method;
    }

    /**
     * http://localhost:8080/exchange
     * @param name zhengke
     * @param request
     * @return
     */
    @PutMapping("/exchange")
    public String exchange(@RequestBody String name,HttpServletRequest request){
        String method = request.getMethod();
        System.out.println("Controller " + name + " method " + method);
        return "Controller " + name + " method " + method;
    }

}

5.测试

1) getForEntity()

@RunWith(SpringRunner.class)
@SpringBootTest
public class GetForEntityTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/get";

    /**
     * (1) public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object...
     * uriVariables) throws RestClientException
     * url：url地址
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void getForEntity1() {
        //1.getForEntity(String url,Class responseType,Object...urlVariables):
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                url+"?name={1}", String.class,"zhengke");
        this.out(responseEntity);
    }
    /**
     * (2) public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType,
     * Map<String, ?> uriVariables) throws RestClientException
     * url：url地址
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void getForEntity2() {
        //2.getForEntity(String url,Class responseType,Map urlVariables):
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                url+"?name={name}", String.class,params);
        this.out(responseEntity);
    }
    /**
     * (3) public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws
     * RestClientException
     * url：url地址
     * responseType：响应实体类型。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void getForEntity3() {
        //3.getForEntity(URI url,Class responseType):
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url+"?name={name}");
        UriComponents uriComponents = uriComponentsBuilder.build().expand("zhengke").encode();
        URI uri = uriComponents.toUri();
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                uri, String.class);
        this.out(responseEntity);
    }

    /**
     * 打印结果
     * @param responseEntity
     */
    private void out(ResponseEntity<String> responseEntity){
        HttpStatus statusCode = responseEntity.getStatusCode();
        String body = responseEntity.getBody();
        HttpHeaders headers = responseEntity.getHeaders();
        int statusCodeValue = responseEntity.getStatusCodeValue();
        Class<? extends ResponseEntity> aClass = responseEntity.getClass();
        System.out.println("statusCode="+statusCode);
        System.out.println("body="+body);
        System.out.println("headers="+headers);
        System.out.println("statusCodeValue="+statusCodeValue);
        System.out.println("aClass="+aClass);
    }

}

2)getForObject()

@RunWith(SpringRunner.class)
@SpringBootTest
public class GetForObjectTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/get";


    /**
     * (1) public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)
     * throws RestClientException
     * url：url地址
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     */
    @Test
    public void getForObject1() {
        //1.getForObject(String url,Class responseType,Object...urlVariables):
        String forObject = restTemplate.getForObject(
                url+"?name={1}", String.class, "zhengke");
        this.out(forObject);
    }

    /**
     * (2) public <T> T getForObject(String url, Class<T> responseType, Map<String, ?>
     *     uriVariables) throws RestClientException
     * url：url地址
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     */
    @Test
    public void getForObject2() {
        //2.getForObject(String url,Class responseType,Map urlVariables):
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        String forObject = restTemplate.getForObject(
                url+"?name={name}", String.class, params);
        this.out(forObject);
    }

    /**
     * (3) public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException
     * url：url地址
     * responseType：响应实体类型。
     */
    @Test
    public void getForObject3() {
        //3.getForObject(URI url,Class responseType):
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url+"?name={name}");
        UriComponents uriComponents = uriComponentsBuilder.build().expand("zhengke").encode();
        URI uri = uriComponents.toUri();
        String forObject = restTemplate.getForObject(
                uri, String.class);
        this.out(forObject);
    }

    /**
     * 打印结果
     * @param forObject
     */
    private void out(String forObject){
        System.out.println(forObject);
    }

}

3)postForEntity()

@RunWith(SpringRunner.class)
@SpringBootTest
public class PostForEntityTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/post";

    /**
     * (1) public <T> ResponseEntity<T>  postForEntity(String url, @Nullable Object request,
     * Class<T> responseType, Object... uriVariables) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应类型
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void postForEntity1() {
        //1.postForEntity(String url,Object request,Class responseType,Object... uriVariables)
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(
                url, "zhengke", String.class);
        this.out(responseEntity);
    }


    /**
     * (2) public <T> ResponseEntity<T>  postForEntity(String url, @Nullable Object request,
     * Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void postForEntity2() {
        //2.postForEntity(String url,Object request,Class responseType,Map uriVariables)
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(
                url,params ,String.class);
        this.out(responseEntity);
    }
    /**
     * (3) public <T> ResponseEntity<T>  postForEntity(URL url, @Nullable Object request,
     * Class<T> responseType,) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应实体类型。
     * 这个方法的返回结果为ResponseEntity，可以从返回结果获取响应状态及响应体等信息。
     */
    @Test
    public void postForEntity3() {
        //3.postForEntity(URI url,Object request，Class responseType)
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url);
        UriComponents uriComponents = uriComponentsBuilder.build().encode();
        URI uri = uriComponents.toUri();
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(
                uri,"name", String.class);
        this.out(responseEntity);
    }

    /**
     * 打印结果
     * @param responseEntity
     */
    private void out(ResponseEntity<String> responseEntity){
        HttpStatus statusCode = responseEntity.getStatusCode();
        String body = responseEntity.getBody();
        HttpHeaders headers = responseEntity.getHeaders();
        int statusCodeValue = responseEntity.getStatusCodeValue();
        Class<? extends ResponseEntity> aClass = responseEntity.getClass();
        System.out.println("statusCode="+statusCode);
        System.out.println("body="+body);
        System.out.println("headers="+headers);
        System.out.println("statusCodeValue="+statusCodeValue);
        System.out.println("aClass="+aClass);
    }
}

4)postForObject()

@RunWith(SpringRunner.class)
@SpringBootTest
public class PostForObjectTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/post";

    /**
     * (1) public <T> T postForObject(String url, @Nullable Object request, Class<T>
     *     responseType, Object... uriVariables) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应类型
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     */
    @Test
    public void postForObject1() {
        //1.postForObject(String url,Object request,Class responseType,Object... uriVariables)
        String forObject = restTemplate.postForObject(
                url, "zhengke", String.class);
        this.out(forObject);
    }

    /**
     * (2) public <T> T postForObject(String url, @Nullable Object request, Class<T>
     *     responseType, Map<String, ?> uriVariables) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应实体类型。
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     */
    @Test
    public void postForObject2() {
        //2.postForObject(String url,Object request,Class responseType,Map uriVariables)
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        String forObject = restTemplate.postForObject(
                url, params, String.class);
        this.out(forObject);

    }

    /**
     * (3) public <T> T postForObject(URL url, @Nullable Object request, Class<T> responseType)
     * throws RestClientException
     * url：url地址
     * request：请求实体对象
     * responseType：响应实体类型。
     */
    @Test
    public void postForObject3() {
        //3.postForObject(URI url,Object request，Class responseType)
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url);
        UriComponents uriComponents = uriComponentsBuilder.build().encode();
        URI uri = uriComponents.toUri();
        String forObject = restTemplate.postForObject(
                uri, "name", String.class);
        this.out(forObject);
    }


    /**
     * 打印结果
     * @param forObject
     */
    private void out(String forObject){
        System.out.println(forObject);
    }
}

5)put()

@RunWith(SpringRunner.class)
@SpringBootTest
public class PutTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/put";

    /**
     * (1) public void put(String url, @Nullable Object request, Object... uriVariables) throws
     * RestClientException
     * url：url地址
     * request：请求实体对象
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     * 注意：这里的put方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void put1() {
        //1.put(String url,Object request,Object... urlVariables)
        restTemplate.put(url, "zhengke");
    }

    /**
     * (2) public void put(String url, @Nullable Object request, Map<String, ?> uriVariables)
     * throws RestClientException
     * url：url地址
     * request：请求实体对象
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     * 注意：这里的put方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void put2() {
        //2.put(String url,Object request,Map urlVariables)
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        restTemplate.put(url,params);
    }

    /**
     * (3) public void put(URL url, @Nullable Object request) throws RestClientException
     * url：url地址
     * request：请求实体对象
     * 注意：这里的put方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void put3() {
        //3.put(URI url,Object request)
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url);
        UriComponents uriComponents = uriComponentsBuilder.build().encode();
        URI uri = uriComponents.toUri();
        restTemplate.put(uri,"name");
    }
}

6)delete()

@RunWith(SpringRunner.class)
@SpringBootTest
public class DeleteTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/delete";
    /**
     * (1) public void delete(String url, Object... uriVariables) throws RestClientException
     * url：url地址
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填。
     * 注意：这里的delete方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void delete1() {
        //1.delete(String url,Object... urlVariables)
        restTemplate.delete(url+"?name={name}", "zhengke");

    }

    /**
     * (2) public void delete(String url, Map<String, ?> uriVariables) throws RestClientException
     * url：url地址
     * uriVariables：url地址参数，如果没有url参数的时候直接传空Map(new HashMap())。
     * 注意：这里的delete方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void delete2() {
        //2.delete(String url,Map urlVariables)
        Map<String,String> params=new HashMap<>();
        params.put("name","zhengke");
        restTemplate.delete(url+"?name={name}",params);

    }
    /**
     * (3) public void delete(URL url) throws RestClientException
     * url：url地址
     * 注意：这里的delete方法没有获取任何响应，那么如果我们要获取响应咋个办呢？那就只有直用exchange方法来实现put请求。
     */
    @Test
    public void delete3() {
        //3.delete(URI url)
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUriString(url+"?name={name}");
        UriComponents uriComponents = uriComponentsBuilder.build().expand("zhengke").encode();
        URI uri = uriComponents.toUri();
        restTemplate.delete(uri);

    }
}

7)核心exchange()

@RunWith(SpringRunner.class)
@SpringBootTest
public class ExchangeTest {
    private RestTemplate restTemplate=new RestTemplate();
    private String url = "http://localhost:8080/exchange";

    /**
     *(1) public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable
     * HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws
     * RestClientException
     * url：url地址
     * method：http请求方法，通过HttpMethod枚举类获取
     * requestEntity：请求实体，可以包含请求头和请求体的信息
     * responseType：响应类型
     * uriVariables：url地址参数，如果url地址上没有参数的，这个参数可以不填
     * 注意：可以实现get、post、put、delete等请求
     * put、delete都没有返回值，这个可以弥补不足。
     */
    @Test
    public void exchange1() {
        //1.exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object...   uriVariables)
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.PUT,
                new HttpEntity<>("zhengke"), String.class);
        this.out(responseEntity);
    }

    /**
     * 打印结果
     * @param responseEntity
     */
    private void out(ResponseEntity<String> responseEntity){
        HttpStatus statusCode = responseEntity.getStatusCode();
        String body = responseEntity.getBody();
        HttpHeaders headers = responseEntity.getHeaders();
        int statusCodeValue = responseEntity.getStatusCodeValue();
        Class<? extends ResponseEntity> aClass = responseEntity.getClass();
        System.out.println("statusCode="+statusCode);
        System.out.println("body="+body);
        System.out.println("headers="+headers);
        System.out.println("statusCodeValue="+statusCodeValue);
        System.out.println("aClass="+aClass);
    }
}