Restful

最新推荐文章于 2022-05-16 07:30:00 发布

不做挖坑人

最新推荐文章于 2022-05-16 07:30:00 发布

阅读量236

点赞数

分类专栏： spring boot

原文链接：https://blog.csdn.net/itguangit/article/details/78825505

版权

spring boot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Restful API 设计指南

REST即表述性状态传递（Representational State Transfer，简称REST），是一种软件架构风格。REST通过HTTP协议定义的通用动词方法(GET、PUT、DELETE、POST) ，以URI对网络资源进行唯一标识，响应端根据请求端的不同需求，通过无状态通信，对其请求的资源进行表述。
Rest架构的主要原则：

网络上的所有事物都被抽象为资源
每个资源都有一个唯一的资源标识符
同一个资源具有多种表现形式(xml,json等)
对资源的各种操作不会改变资源标识符
所有的操作都是无状态的

其中表述性状态，是指(在某个瞬间状态的)资源数据的快照，包括资源数据的内容、表述格式(XML、JSON)等信息。

其中无状态通信，是指服务端(响应端)不保存任何与特定HTTP请求相关的资源，应用状态必须由请求方在请求过程中提供。要求在网络通信过程中，任意一个Web请求必须与其他请求隔离，当请求端提出请求时，请求本身包含了响应端为响应这一请求所需的全部信息。

REST使用HTTP+URI+XML /JSON 的技术来实现其API要求的架构风格：HTTP协议和URI用于统一接口和定位资源，文本、二进制流、XML、JSON等格式用来作为资源的表述。

举例：

在Restful之前的操作：

请求的地址对应具体的业务操作

http://127.0.0.1/user/query/1 GET 根据用户id查询用户数据
http://127.0.0.1/user/save       POST 新增用户
http://127.0.0.1/user/update   POST 修改用户信息
http://127.0.0.1/user/delete    GET/POST 删除用户信息

RESTful用法：请求

http://127.0.0.1/user/1   GET 根据用户id查询用户数据
http://127.0.0.1/user    POST 新增用户
http://127.0.0.1/user      PUT 修改用户信息
http://127.0.0.1/user      DELETE 删除用户信息

RESTful风格的体现，

使用get请求，就是查询；
使用post请求,就是新增；
使用put请求，就是修改；
使用delete请求，就是删除。

这样做就完全没有必要对crud做具体的描述。满足REST约束条件和原则的架构，就被称为是RESTful架构。就像URL都是URI(统一资源标识)的表现形式一样，RESTful是符合REST原则的表现形式。

使用 RestTemplate 调用 restful 服务

RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。
调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。
ClientHttpRequestFactory接口主要提供了两种实现方式

一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式创建底层的Http请求连接。
一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

RestTemplate默认是使用SimpleClientHttpRequestFactory，内部是调用jdk的HttpConnection，默认超时为-1

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class SpringbootRestTemplateApplication {
    
    // 启动的时候要注意，由于我们在controller中注入了RestTemplate，所以启动的时候需要实例化该类的一个实例
    @Autowired
    private RestTemplateBuilder builder;

    // 使用RestTemplateBuilder来实例化RestTemplate对象，spring默认已经注入了RestTemplateBuilder实例
    @Bean
    public RestTemplate restTemplate() {
        return builder.build();
    }

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.chhliu.springboot.restful.vo.User;

@RestController
public class RestTemplateController {
    
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/template/{id}")
    public User findById(@PathVariable Long id) {
        //http://localhost:8080/user/ 是服务的对应的url
        User u = this.restTemplate.getForObject("http://localhost:8080/user/" + id,User.class);
        System.out.println(u);
        return u;
    }
}

Spring 中如何使用Rest资源

借助 RestTemplate，Spring应用能够方便地使用REST资源
Spring的 RestTemplate访问使用了模版方法的设计模式.

模版方法将过程中与特定实现相关的部分委托给接口,而这个接口的不同实现定义了接口的不同行为.

RestTemplate定义了36个与REST资源交互的方法，其中的大多数都对应于HTTP的方法。
其实，这里面只有11个独立的方法，其中有十个有三种重载形式，而第十一个则重载了六次，这样一共形成了36个方法。

delete() 在特定的URL上对资源执行HTTP DELETE操作
exchange()在URL上执行特定的HTTP方法，返回包含对象的ResponseEntity，这个对象是从响应体中
映射得到的
execute() 在URL上执行特定的HTTP方法，返回一个从响应体映射得到的对象
getForEntity() 发送一个HTTP GET请求，返回的ResponseEntity包含了响应体所映射成的对象
getForObject() 发送一个HTTP GET请求，返回的请求体将映射为一个对象
postForEntity() POST 数据到一个URL，返回包含一个对象的ResponseEntity，这个对象是从响应体中映射得到的
postForObject() POST 数据到一个URL，返回根据响应体匹配形成的对象
headForHeaders() 发送HTTP HEAD请求，返回包含特定资源URL的HTTP头
optionsForAllow() 发送HTTP OPTIONS请求，返回对特定URL的Allow头信息
postForLocation() POST 数据到一个URL，返回新创建资源的URL
put() PUT 资源到特定的URL

实际上,由于Post 操作的非幂等性,它几乎可以代替其他的CRUD操作.

Get请求

RestTemplate 的get方法有以上几个,可以分为两类: getForEntity() 和 getForObject()

首先看 getForEntity() 的返回值类型 ResponseEntity

<T> ResponseEntity<T> getForEntity()

看一下 ResponseEntity 的文档描述:

可以看到它继承了HttpEntity. 封装了返回的响应信息,包括 响应状态,响应头和响应体.

在测试之前我们首先创建一个Rest服务,模拟提供Rest数据,这里给出Controller层代码,具体可以查看源码,文章最后会给出:

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "getAll")
    public List<UserEntity> getUser() {
        List<UserEntity> list = userService.getAll();
        return list;
    }

    @RequestMapping("get/{id}")
    public UserEntity getById(@PathVariable(name = "id") String id) {

        return userService.getById(id);
    }


    @RequestMapping(value = "save")
    public String save(UserEntity userEntity) {

        return "保存成功";
    }


    @RequestMapping(value = "saveByType/{type}")
    public String saveByType(UserEntity userEntity,@PathVariable("type")String type) {

        return "保存成功,type="+type;
    }

}

测试: getForEntity

无参数的 getForEntity 方法

 @RequestMapping("getForEntity")
    public List<UserEntity> getAll2() {
        ResponseEntity<List> responseEntity = restTemplate.getForEntity("http://localhost/getAll", List.class);
        HttpHeaders headers = responseEntity.getHeaders();
        HttpStatus statusCode = responseEntity.getStatusCode();
        int code = statusCode.value();

        List<UserEntity> list = responseEntity.getBody();

        System.out.println(list.toString());
        return list;

    }

有参数的 getForEntity 请求,参数列表,可以使用 {} 进行url路径占位符

 //有参数的 getForEntity 请求,参数列表   
 @RequestMapping("getForEntity/{id}")
    public UserEntity getById2(@PathVariable(name = "id") String id) {

        ResponseEntity<UserEntity> responseEntity = restTemplate.getForEntity("http://localhost/get/{id}", UserEntity.class, id);
        UserEntity userEntity = responseEntity.getBody();
        return userEntity;
    }

有参数的 get 请求,使用map封装参数

 //有参数的 get 请求,使用map封装参数
    @RequestMapping("getForEntity/{id}")
    public UserEntity getById4(@PathVariable(name = "id") String id) {
        HashMap<String, String> map = new HashMap<>();
        map.put("id",id);

        ResponseEntity<UserEntity> responseEntity = restTemplate.getForEntity("http://localhost/get/{id}", UserEntity.class, map);
        UserEntity userEntity = responseEntity.getBody();

        return userEntity;
    }

通过断点调试我们看下返回的 responseEntity 的信息如图:

因此我们可以获取Http请求的全部信息.

但是,通常情况下我们并不想要Http请求的全部信息,只需要相应体即可.对于这种情况,RestTemplate提供了 getForObject() 方法用来只获取响应体信息.
getForObject 和 getForEntity 用法几乎相同,指示返回值返回的是响应体,省去了我们再去 getBody() .
测试: getForObject

无参数的 getForObject 请求

//无参数的 getForObject 请求
    @RequestMapping("getAll2")
    public List<UserEntity> getAll() {
        List<UserEntity> list = restTemplate.getForObject("http://localhost/getAll", List.class);


        System.out.println(list.toString());
        return list;

    }

有参数的 getForObject 请求,使用参数列表


    //有参数的 getForObject 请求
    @RequestMapping("get2/{id}")
    public UserEntity getById(@PathVariable(name = "id") String id) {

        UserEntity userEntity = restTemplate.getForObject("http://localhost/get/{id}", UserEntity.class, id);

        return userEntity;
    }

有参数的 get 请求,使用map封装请求参数

 //有参数的 get 请求,使用map封装请求参数
    @RequestMapping("get3/{id}")
    public UserEntity getById3(@PathVariable(name = "id") String id) {
        HashMap<String, String> map = new HashMap<>();
        map.put("id",id);

        UserEntity userEntity = restTemplate.getForObject("http://localhost/get/{id}", UserEntity.class, map);

        return userEntity;
    }

Post请求

了解了get请求后,Post请求就变得很简单了,我们可以看到post有如下方法:

测试: postForEntity

post 请求,保存 UserEntity 对像


    //post 请求,提交 UserEntity 对像

    @RequestMapping("saveUser")
    public String save(UserEntity userEntity) {

        ResponseEntity<String> responseEntity = restTemplate.postForEntity("http://localhost/save", userEntity, String.class);
        String body = responseEntity.getBody();

        return body;

    }

浏览器访问: http://localhost/saveUser?username=itguang&password=123456&age=20&email=123@123.com

我们再次断点调试,查看 responseEntity 中的信息:

有参数的 postForEntity 请求

   // 有参数的 postForEntity 请求
    @RequestMapping("saveUserByType/{type}")
    public String save2(UserEntity userEntity,@PathVariable("type")String type) {

        ResponseEntity<String> responseEntity = restTemplate.postForEntity("http://localhost/saveByType/{type}", userEntity, String.class, type);
        String body = responseEntity.getBody();

        return body;

    }
 // 有参数的 postForEntity 请求,使用map封装
    @RequestMapping("saveUserByType2/{type}")
    public String save3(UserEntity userEntity,@PathVariable("type")String type) {
        HashMap<String, String> map = new HashMap<>();
         map.put("type", type);


        ResponseEntity<String> responseEntity = restTemplate.postForEntity("http://localhost/saveByType/{type}", userEntity, String.class,map);
        String body = responseEntity.getBody();

        return body;

    }