//本文作者：cuifuan

//本文将收录到菜单栏：《Spring全家桶》专栏中

Spring Boot通过提供开箱即用的默认依赖或者转换来补充Spring REST支持。在Spring Boot中编写RESTful服务与SpringMVC没有什么不同。总而言之，基于Spring Boot的REST服务与基于Spring的REST服务完全相同，只是在我们引导底层应用程序的方式上有所不同。

1.REST简短介绍

REST代表Representational State Transfer. 是一种架构风格，设计风格而不是标准，可用于设计Web服务，可以从各种客户端使用.

基于REST的基本设计，其是根据一组动词来控制的操作

• 创建操作：应使用HTTP POST

• 查询操作：应使用HTTP GET

• 更新操作：应使用HTTP PUT

• 删除操作：应使用HTTP DELETE

作为REST服务开发人员或客户端，您应该遵守上述标准。

2.准备工作

项目的环境工具

• SpringBoot 2.0.1.RELEASE

• Gradle 4.7

• IDEA 2018.2

• MySQL5.7

项目结构图

3.开始

下面基于一种方式讲解Restful

1. package com.example.controller;

3. import com.example.beans.PageResultBean;

4. import com.example.beans.ResultBean;

5. import com.example.entity.User;

6. import com.example.service.UserService;

7. import org.springframework.beans.factory.annotation.Autowired;

8. import org.springframework.web.bind.annotation.PathVariable;

9. import org.springframework.web.bind.annotation.RequestMapping;

10. import org.springframework.web.bind.annotation.RequestMethod;

11. import org.springframework.web.bind.annotation.RestController;

13. import java.util.List;

15. @RestController

16. @RequestMapping("/user")

17. public class UserControllerAPI {

19.    private final UserService userService;

21.    @Autowired

22.    public UserControllerAPI(UserService userService) {

23.        this.userService = userService;

24.    }

26.    @RequestMapping(value = "/api", method = RequestMethod.GET)

27.    public PageResultBean<List<User>> getUserAll(PageResultBean page) {

28.        return new PageResultBean<>(userService.getUserAll(page.getPageNo(), page.getPageSize()));

29.    }

31.    @RequestMapping(value = "/api/{id}", method = RequestMethod.GET)

32.    public ResultBean<User> getUserByPrimaryKey(@PathVariable("id") Integer id) {

33.        return new ResultBean<>(userService.selectByPrimaryKey(id));

34.    }

36.    @RequestMapping(value = "/api/{id}", method = RequestMethod.PUT)

37.    public ResultBean<Integer> updateUserByPrimaryKey(@PathVariable("id") Integer id,User user) {

38.        user.setId(id);

39.        return new ResultBean<>(userService.updateByPrimaryKeySelective(user));

40.    }

42.    @RequestMapping(value = "/api/{id}", method = RequestMethod.DELETE)

43.    public ResultBean<String> deletePrimaryKey(@PathVariable("id") Integer id) {

44.        return new ResultBean<>(userService.deleteByPrimaryKey(id));

45.    }

47.    @RequestMapping(value = "/api", method = RequestMethod.POST)

48.    public ResultBean<Integer> deletePrimaryKey(User user) {

49.        return new ResultBean<>(userService.insertSelective(user));

50.    }

52. }

• 对于/user/api HTTP GET来请求获取全部用户

• 对于/user/api HTTP POST来创建用户

• 对于/user/api/1 HTTP GET请求来获取id为1的用户

• 对于/user/api/1 HTTP PUT请求来更新

• 对于/user/api/1 HTTP DELETE请求来删除id为1的用户

HTTP GET请求/user/api 查询全部

URL：http://localhost:8080/user/api

HTTP GET请求/user/api/65 跟据id查询

URL:http://localhost:8080/user/api/65

HTTP POST请求/user/api 创建用户

URL:http://localhost:8080/user/api

HTTP PUT请求/user/api/65 来更新用户信息

URL:http://localhost:8080/user/api/65

HTTP DELETE请求/user/api/85 来删除id为85的用户

URL:http://localhost:8080/user/api/85

4.业务层及dao层代码

UserService.java 接口

1. package com.example.service;

3. import com.example.entity.User;

5. import java.util.List;

7. public interface UserService {

9.    /**

10.     * 删除

11.     * @param id

12.     * @return

13.     */

14.    String deleteByPrimaryKey(Integer id);

16.    /**

17.     * 创建

18.     * @param record

19.     * @return

20.     */

21.    int insertSelective(User record);

23.    /**

24.     * 单个查询

25.     * @param id

26.     * @return

27.     */

28.    User selectByPrimaryKey(Integer id);

30.    /**

31.     * 更新

32.     * @param record

33.     * @return

34.     */

35.    int updateByPrimaryKeySelective(User record);

37.    /**

38.     * 查询全部

39.     * @return

40.     */

41.    List<User> getUserAll(Integer pageNum, Integer pageSize);

42. }

UserServiceImpl.java

1. package com.example.service.impl;

3. import com.example.dao.UserMapper;

4. import com.example.entity.User;

5. import com.example.service.UserService;

6. import com.github.pagehelper.PageHelper;

7. import org.slf4j.Logger;

8. import org.slf4j.LoggerFactory;

9. import org.springframework.beans.factory.annotation.Autowired;

10. import org.springframework.stereotype.Service;

11. import org.springframework.transaction.annotation.Transactional;

13. import java.util.List;

15. @Service

16. public class UserServiceImpl implements UserService {

18.    private final static Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);

20.    private final UserMapper userMapper;

22.    @Autowired(required = false)

23.    public UserServiceImpl(UserMapper userMapper) {

24.        this.userMapper = userMapper;

25.    }

27.    /**

28.     * 删除

29.     *

30.     * @param id

31.     * @return

32.     */

33.    @Transactional

34.    @Override

35.    public String deleteByPrimaryKey(Integer id) {

36.        logger.info("UserServiceImpl deleteByPrimaryKey id => " + id);

37.        User user = userMapper.selectByPrimaryKey(id);

38.        String result;

39.        if (user == null) {

40.            result = "用户ID[" + id + "]找不到!";

41.        } else {

42.            result = String.valueOf(userMapper.deleteByPrimaryKey(id));

43.        }

44.        return result;

45.    }

47.    /**

48.     * 创建

49.     *

50.     * @param record

51.     * @return

52.     */

53.    @Transactional

54.    @Override

55.    public int insertSelective(User record) {

56.        logger.info("UserServiceImpl insertSelective record=>"+record.toString());

57.        return userMapper.insertSelective(record);

58.    }

60.    /**

61.     * 单个查询

62.     *

63.     * @param id

64.     * @return

65.     */

66.    @Override

67.    public User selectByPrimaryKey(Integer id) {

68.        logger.info("UserServiceImpl selectByPrimaryKey id=>"+id);

69.        return userMapper.selectByPrimaryKey(id);

70.    }

72.    /**

73.     * 更新

74.     *

75.     * @param record

76.     * @return

77.     */

78.    @Override

79.    public int updateByPrimaryKeySelective(User record) {

80.        logger.info("UserServiceImpl updateByPrimaryKeySelective record=>"+record.toString());

81.        return userMapper.updateByPrimaryKeySelective(record);

82.    }

84.    /**

85.     * 查询全部

86.     *

87.     * @param pageNum

88.     * @param pageSize

89.     * @return

90.     */

91.    @Override

92.    public List<User> getUserAll(Integer pageNum, Integer pageSize) {

93.        logger.info("UserServiceImpl getUserAll pageNum=>"+pageNum+"=>pageSize=>"+pageSize);

94.        PageHelper.startPage(pageNum,pageSize);

95.        List<User> userList = userMapper.getUserAll();

96.        logger.info("UserServiceImpl getUserAll userList"+userList.size());

97.        return userList;

98.    }

99. }

UserMapper.java

1. package com.example.dao;

3. import com.example.entity.User;

5. import java.util.List;

7. public interface UserMapper {

8.    int deleteByPrimaryKey(Integer id);

10.    int insert(User record);

12.    int insertSelective(User record);

14.    User selectByPrimaryKey(Integer id);

16.    int updateByPrimaryKeySelective(User record);

18.    int updateByPrimaryKey(User record);

20.    List<User> getUserAll();

21. }

PageResultBean和ResultBean的代码在GitHub

https://github.com/cuifuan/springboot-demo

实体层和mapper.xml代码都是可以自动生成的，教程导航：

Spring全家桶系列--SpringBoot与Mybatis结合

4.理解RESTful

通过上面的编码，如果你已经走通了上面的代码，相信你已经对REST有了大致的掌握，时今当下的前端Client层出不穷，后端接口或许来自不同平台，这时候需要请求一批接口，而RESTful风格的api，使人从请求方式和地址一看就知道是要做什么操作，根据返回code状态就知道结果如何

使用RESTful直接带来的便利：

之前的接口

• 删除 /user/delete

• 添加 /user/create

• 单个查询 /user/queryById

• 查询全部 /user/queryAll

• 更新 /user/update

采用RESTful设计API之后 /user/api一个URL地址解决，再也不用跟前端废舌头了，同时GET请求是幂等的，什么是幂等？简单通俗的说就是多次请求返回的效果都是相同的，例如GET去请求一个资源，无论请求多少次，都不会对数据造成创建修改等操作，PUT用来更新数据也是，无论执行多次的都是最终一样的效果

问题：使用PUT改变学生年龄并且这样做10次和做了一次，学生的年龄是相同的,是幂等的，那么如果POST做相同操作，那么它是如何不是幂等的？

答：因为POST请求会在服务端创建与请求次数相同的服务，假如服务端每次请求服务会存在一个密钥，那么这个POST请求就可能不是幂等的，也或许是幂等的，所以POST不是幂等的。

因为PUT请求URL到客户端定义的URL处完整地创建或替换资源，所以PUT是幂等的。 DELETE请求也是幂等的，用来删除操作，其实REST就是相当于一个风格规范。

注意了，GET请求请不要用在delete操作上，你要问我为啥不行，你偏要那么做，其实，整个CRUD操作你也都可以用GET来完成，哈哈，这个只是一个开发的设计风格。

点击图片加入Spring交流群

↓↓↓

看完本文有收获？请转发分享给更多人