Spring全家桶–SpringBoot Rest API


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
项目结构图
Spring全家桶--SpringBoot Rest API

3.开始

下面基于一种方式讲解Restful
  1. package com.example.controller;
  2. import com.example.beans.PageResultBean;
  3. import com.example.beans.ResultBean;
  4. import com.example.entity.User;
  5. import com.example.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RequestMethod;
  10. import org.springframework.web.bind.annotation.RestController;
  11. import java.util.List;
  12. @RestController
  13. @RequestMapping("/user")
  14. publicclassUserControllerAPI{
  15.    privatefinalUserService userService;
  16.    @Autowired
  17.    publicUserControllerAPI(UserService userService){
  18.        this.userService = userService;
  19.    }
  20.    @RequestMapping(value ="/api", method =RequestMethod.GET)
  21.    publicPageResultBean<List<User>> getUserAll(PageResultBean page){
  22.        returnnewPageResultBean<>(userService.getUserAll(page.getPageNo(), page.getPageSize()));
  23.    }
  24.    @RequestMapping(value ="/api/{id}", method =RequestMethod.GET)
  25.    publicResultBean<User> getUserByPrimaryKey(@PathVariable("id")Integer id){
  26.        returnnewResultBean<>(userService.selectByPrimaryKey(id));
  27.    }
  28.    @RequestMapping(value ="/api/{id}", method =RequestMethod.PUT)
  29.    publicResultBean<Integer> updateUserByPrimaryKey(@PathVariable("id")Integer id,User user){
  30.        user.setId(id);
  31.        returnnewResultBean<>(userService.updateByPrimaryKeySelective(user));
  32.    }
  33.    @RequestMapping(value ="/api/{id}", method =RequestMethod.DELETE)
  34.    publicResultBean<String> deletePrimaryKey(@PathVariable("id")Integer id){
  35.        returnnewResultBean<>(userService.deleteByPrimaryKey(id));
  36.    }
  37.    @RequestMapping(value ="/api", method =RequestMethod.POST)
  38.    publicResultBean<Integer> deletePrimaryKey(User user){
  39.        returnnewResultBean<>(userService.insertSelective(user));
  40.    }
  41. }

  • 对于/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
Spring全家桶--SpringBoot Rest API
HTTP GET请求/user/api/65 跟据id查询
URL:http://localhost:8080/user/api/65
Spring全家桶--SpringBoot Rest API
HTTP POST请求/user/api 创建用户
URL:http://localhost:8080/user/api
Spring全家桶--SpringBoot Rest API
HTTP PUT请求/user/api/65 来更新用户信息
URL:http://localhost:8080/user/api/65
Spring全家桶--SpringBoot Rest API
HTTP DELETE请求/user/api/85 来删除id为85的用户
URL:http://localhost:8080/user/api/85
Spring全家桶--SpringBoot Rest API

4.业务层及dao层代码

UserService.java 接口
  1. package com.example.service;
  2. import com.example.entity.User;
  3. import java.util.List;
  4. publicinterfaceUserService{
  5.    /**
  6.     * 删除
  7.     * @param id
  8.     * @return
  9.     */
  10.    String deleteByPrimaryKey(Integer id);
  11.    /**
  12.     * 创建
  13.     * @param record
  14.     * @return
  15.     */
  16.    int insertSelective(User record);
  17.    /**
  18.     * 单个查询
  19.     * @param id
  20.     * @return
  21.     */
  22.    User selectByPrimaryKey(Integer id);
  23.    /**
  24.     * 更新
  25.     * @param record
  26.     * @return
  27.     */
  28.    int updateByPrimaryKeySelective(User record);
  29.    /**
  30.     * 查询全部
  31.     * @return
  32.     */
  33.    List<User> getUserAll(Integer pageNum,Integer pageSize);
  34. }
UserServiceImpl.java
  1. package com.example.service.impl;
  2. import com.example.dao.UserMapper;
  3. import com.example.entity.User;
  4. import com.example.service.UserService;
  5. import com.github.pagehelper.PageHelper;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  10. import org.springframework.transaction.annotation.Transactional;
  11. import java.util.List;
  12. @Service
  13. publicclassUserServiceImplimplementsUserService{
  14.    privatefinalstaticLogger logger =LoggerFactory.getLogger(UserServiceImpl.class);
  15.    privatefinalUserMapper userMapper;
  16.    @Autowired(required =false)
  17.    publicUserServiceImpl(UserMapper userMapper){
  18.        this.userMapper = userMapper;
  19.    }
  20.    /**
  21.     * 删除
  22.     *
  23.     * @param id
  24.     * @return
  25.     */
  26.    @Transactional
  27.    @Override
  28.    publicString deleteByPrimaryKey(Integer id){
  29.        logger.info("UserServiceImpl deleteByPrimaryKey id => "+ id);
  30.        User user = userMapper.selectByPrimaryKey(id);
  31.        String result;
  32.        if(user ==null){
  33.            result ="用户ID["+ id +"]找不到!";
  34.        }else{
  35.            result =String.valueOf(userMapper.deleteByPrimaryKey(id));
  36.        }
  37.        return result;
  38.    }
  39.    /**
  40.     * 创建
  41.     *
  42.     * @param record
  43.     * @return
  44.     */
  45.    @Transactional
  46.    @Override
  47.    publicint insertSelective(User record){
  48.        logger.info("UserServiceImpl insertSelective record=>"+record.toString());
  49.        return userMapper.insertSelective(record);
  50.    }
  51.    /**
  52.     * 单个查询
  53.     *
  54.     * @param id
  55.     * @return
  56.     */
  57.    @Override
  58.    publicUser selectByPrimaryKey(Integer id){
  59.        logger.info("UserServiceImpl selectByPrimaryKey id=>"+id);
  60.        return userMapper.selectByPrimaryKey(id);
  61.    }
  62.    /**
  63.     * 更新
  64.     *
  65.     * @param record
  66.     * @return
  67.     */
  68.    @Override
  69.    publicint updateByPrimaryKeySelective(User record){
  70.        logger.info("UserServiceImpl updateByPrimaryKeySelective record=>"+record.toString());
  71.        return userMapper.updateByPrimaryKeySelective(record);
  72.    }
  73.    /**
  74.     * 查询全部
  75.     *
  76.     * @param pageNum
  77.     * @param pageSize
  78.     * @return
  79.     */
  80.    @Override
  81.    publicList<User> getUserAll(Integer pageNum,Integer pageSize){
  82.        logger.info("UserServiceImpl getUserAll pageNum=>"+pageNum+"=>pageSize=>"+pageSize);
  83.        PageHelper.startPage(pageNum,pageSize);
  84.        List<User> userList = userMapper.getUserAll();
  85.        logger.info("UserServiceImpl getUserAll userList"+userList.size());
  86.        return userList;
  87.    }
  88. }
UserMapper.java
  1. package com.example.dao;
  2. import com.example.entity.User;
  3. import java.util.List;
  4. publicinterfaceUserMapper{
  5.    int deleteByPrimaryKey(Integer id);
  6.    int insert(User record);
  7.    int insertSelective(User record);
  8.    User selectByPrimaryKey(Integer id);
  9.    int updateByPrimaryKeySelective(User record);
  10.    int updateByPrimaryKey(User record);
  11.    List<User> getUserAll();
  12. }
PageResultBean和ResultBean的代码在GitHub
https://github.com/cuifuan/springboot-demo
实体层和mapper.xml代码都是可以自动生成的,教程导航:

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全家桶–SpringBoot Rest API
分享到:
赞(0)

评论抢沙发

评论前必须登录!