• SpringBoot整合SSMP

    项目总体实现技术要求如图所示：

    一、springboot整合ssmp

    1.1、模块创建

    手动添加mybatis-plus坐标依赖：

     配置端口号：

     

    1.2、实体类快速开发（基于lombok）

     

     假设项目中所用到的数据库信息如下所示：

     我们的实体类Book的属性名要保证和数据库的字段名一致，因为我们的实体类属性就是用来封装数据库中的数据信息的，如果名字都不一样的话，数据库中的数据就封装不到实体类的属性中

    1.3、数据层开发

     

     我们前面的springboot整合druid笔记讲过，整合druid的时候只需要在yml配置文件中配置druid数据库信息即可，这样就可以让数据层和数据库相连了。

    1.3.1、我们以前使用mybatis的时候，数据层的写法如下所示：

    ：先在yml配置文件中把druid数据源的信息配置出来（相当于连接数据库，配置完后数据层就可以写sql语句对数据库进行操作了）

     数据层：

     测试结果：

    1.3.2、使用mybatis-plus的话有什么用处呢：（作用：简化数据层的sql语句，直接就不用写数据层的增删改查功能方法了）

    注1：使用mybatis-plus方式一定不能忘记在yml配置文件中配置属性：

    使用mybatis-plus的形式的话，我们需要继承BaseMapper 并且泛型要是封装数据库数据的POJO实体类
*
*  使用mybatis-plus的话，在数据层的增删改查功能方法直接就不用写了，BaseMapper对象中已经封装好了，
*  我们数据层继承了BaseMapper就说明继承了BaseMapper的增删改查功能了，直接调用增删改查功能方法就行了

    使用mybatis-plus方式数据层如下： 

     BaseMapper对象中已经写好的增删改查方法：

    测试程序：（这个增删改查的方法名就要遵守BaseMapper对象中的增删改查的方法名了，因为毕竟我们数据层增删改查的方法是继承的BaseMapper对象的）

    但是使用mybatis-plus方式进行保存功能的时候会有一点问题：

    问题1：进行保存功能的时候要在yml配置文件中配置id自动增长

     报错信息：

     我们知道我们数据库中的id本来设置成的是自动增长的，本来调用保存功能时不写id（不写该setId()方法）是不用应该报错的，

    我们这个报错如何解决呢：需要我们在yml配置文件中配置一下信息：

     配置好yml属性之后，还用上面的测试保存的代码再测试保存功能：（会发现数据就能保存成功了） 

    问题2：进行查询所有数据功能的时候，要在调用BaseMapper对象中的查询所有功能的方法中随便传入一个参数

    1.3.3、开启mybatis-plus运行日志

     

     配置完运行日志后，假设进行查询所有测试：

    1.4、分页

    我们知道数据层BookMapper接口继承了BaseMapper对象，BaseMapper对象当中封装好了增删改查，分页查询等等所有的功能方法，不例外的是当然也封装好了分页查询的功能方法

    其实分页查询的功能实现就三个步骤：

    第一步：new Page对象把想要查询的页数和每页展示的数据量传递进去

    第二步：调用数据层的分页查询功能方法，把第一步的对象传递进去，并且第二个参数任意设定（一般都设定为null）

    第三步：设定分页查询拦截器（要不设定的话，尽管调用的是分页查询的功能，但是却拿到的是数据库中的全部数据信息）

    分页查询功能程序测试如下：

     结果：

     因此：思考为什么我们明明测试的是分页查询的功能，却还是把数据库中的所有数据都展示给我们了呢，那么我们到底如何才能获取到分页查询出来的数据呢：

    解决方法：就需要我们设定一个分页查询的拦截器（配置完之后，就可以拿到分页查询的数据了，而不是调用分页查询功能的时候把所有的数据库数据都拿到）

    1. /**
    2.  *  分页查询拦截器类 (该拦截器的写法其实是固定的)
    3.  *
    4.  */
    5.  
    6. @Configuration  // 加载器注解 作用：使用该注解后，当运行springboot类的时候会自动加载到该拦截器类
    7. public class MPConfig {
    8.  
    9.     @Bean
    10.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
    11.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    12.         // 添加个分页查询拦截器
    13.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
    14.         // 添加完后返回即可
    15.         return interceptor;
    16.     }
    17. }

    当配置好分页查询拦截器后，我们测试程序再次调用数据层分页查询功能，看是否能拿到第一页的五条数据：

     

    补充能量：使用Page对象调用某些方法可以拿到我们获取到的数据的某些信息：

    1.5、条件查询 （like）

    *      条件查询的功能实现步骤：
*      第一步：new QueryWrapper对象
*      第二步：用该对象调用like属性（第一个参数对应的是数据库的字段名，第二个参数对应的是对该字段名模糊查询的数据）
*      第三步：调用数据层的条件查询功能

    问题1：有时候我们有可能会把like属性中的第一个参数（对应的是数据库的字段名）写错，那么我们的sql语句肯定就错误了，数据当然也是拿不出来了：

    因此我们有什么方法能够防止第一个参数写的数据库字段名出错呢：

    解决方法： 用Lambda对象方式

    问题2：我们知道like属性后的第二个参数是来自前端条件查询的数据，但是我们想保证前端查询的数据不为null，为null的话就不让他进行条件查询了：

    因此为null的时候，我们不想让他进行条件查询 （where xxxx like xxxx），我们该怎么做呢：

    1.6、业务层开发

    注意：数据层我们就用的是mybatis-plus帮我们封装好到BaseMapper对象当中的增删改查等功能代码，因此我们业务层调用数据层的增删改查等功能方法时，要遵守BaseMapper对象当中的增删改查等功能的方法名

    其实业务层开发的方法名和数据层开发的方法名还是有一点区别的（以前我们都是说业务层的代码直接复制数据层的代码就行了，再写点其他的业务逻辑就完成了）

     

     业务层代码：

    BookService：

    1. package com.Bivin.service;
    2.  
    3. import com.Bivin.pojo.Book;
    4. import com.baomidou.mybatisplus.core.metadata.IPage;
    5. import org.springframework.stereotype.Component;
    6. import org.springframework.stereotype.Service;
    7.  
    8. import java.util.List;
    9.  
    10. /**
    11.  *  业务层接口
    12.  */
    13.  
    14.  
    15. public interface BookService {
    16.  
    17.     /**
    18.      * 增加功能
    19.      *
    20.      * 数据保存成功的话返回给用户boolean类型
    21.      */
    22.     boolean save(Book book);
    23.  
    24.     /**
    25.      * 删除功能
    26.      *
    27.      * 数据删除成功的话返回给用户boolean类型
    28.      */
    29.     boolean delete(Integer id);
    30.  
    31.     /**
    32.      * 改功能
    33.      *
    34.      * 数据修改成功的话返回给用户boolean类型
    35.      */
    36.     boolean update(Book book);
    37.  
    38.     /**
    39.      * 查询功能
    40.      *
    41.      * 数据查询成功的话返回给用户List集合，把所有的数据以List集合的形式返回给前端用户
    42.      */
    43.     List selectAll();
    44.  
    45.     /**
    46.      * 通过id查询功能
    47.      *
    48.      * 数据查询成功的话返回给用户Book类型，把单条数据封装到Book对象属性中返回给前端用户
    49.      */
    50.     Book selectById(Integer id);
    51.  
    52.     /**
    53.      *  分页查询功能
    54.      *
    55.      *      int currentPage ： 对应的是第几页
    56.      *      int pageSize ： 对应的是每页查询的数据个数
    57.      */
    58.     IPage getByPage(int currentPage,int pageSize);
    59.  
    60. }

    实现接口类：

    注意：bean注解放实现接口类当中，要不然扫描不到bean对象

    1. package com.Bivin.service.impl;
    2.  
    3. import com.Bivin.mapper.BookMapper;
    4. import com.Bivin.pojo.Book;
    5. import com.Bivin.service.BookService;
    6. import com.baomidou.mybatisplus.core.metadata.IPage;
    7. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Service;
    10.  
    11. import java.util.List;
    12.  
    13. /**
    14.  *  业务层
    15.  */
    16.  
    17. @Service    // bean 注解  注意：该bean注解不要写在接口上，因为接口不是对象2
    18. public class BookServiceImpl implements BookService {
    19.  
    20.     /**
    21.      *  添加业务层和数据层之间的依赖关系（使用自动装配获取到数据层对象，然后在业务层的增删改查方法中调用数据层的增删改查方法）
    22.      */
    23.     @Autowired
    24.     private BookMapper bookMapper;
    25.  
    26.     // 增
    27.     @Override
    28.     public boolean save(Book book) {
    29.         // 调用数据层的增加功能
    30.        return bookMapper.insert(book) >0;
    31.        // 注意：数据层的增删改查功能返回的都是int类型：int insert(T entity); 表示的是受影响的行数
    32.         // 每保存一条数据，受影响的行数就是1
    33.         // 我们这里保存成功的话返回给用户的是 return bookMapper.insert(book) >0;  表示return 1 > 0; 为true 所以就可以返回boolean类型了
    34.             //  bookMapper.insert(book) 受影响的行数为1
    35.     }
    36.  
    37.     // 删
    38.     @Override
    39.     public boolean delete(Integer id) {
    40.         // 调用数据层的删除功能
    41.         return bookMapper.deleteById(id) >0;
    42.     }
    43.  
    44.     // 改
    45.     @Override
    46.     public boolean update(Book book) {
    47.         // 调用数据层的修改功能
    48.         return bookMapper.updateById(book) >0;
    49.     }
    50.  
    51.     // 查
    52.     @Override
    53.     public List selectAll() {
    54.         // 调用数据层的查询功能
    55.         return bookMapper.selectList(null);
    56.     }
    57.  
    58.     // 通过id查单条数据
    59.     @Override
    60.     public Book selectById(Integer id) {
    61.         // 调用数据层通过id查单条数据功能
    62.         return bookMapper.selectById(id);
    63.     }
    64.  
    65.  
    66.     // 分页查询功能
    67.  
    68.     /**     // 分页查询功能
    69.      *
    70.      *      int currentPage ： 对应的是第几页
    71.      *      int pageSize ： 对应的是每页查询的数据个数
    72.      *
    73.      *      注：使用mybatis-plus方式的话，因为人家封装好的分页查询功能返回的类型是IPage<实体类>类型，
    74.      *      因此我们的分页查询功能的方法返回类型设置成IPage<>形式
    75.      *
    76.      *
    77.      */
    78.     @Override
    79.     public IPage getByPage(int currentPage, int pageSize) {
    80.         // 调用数据层的分页查询功能
    81.         IPage page = new Page<>(currentPage,pageSize);
    82.         bookMapper.selectPage(page,null);// 把对应的页数和展示数据数传入数据层分页查询功能
    83.         return page;
    84.     }
    85.  
    86. }

    程序测试：

    补充：其实业务层也可以用mybatis-plus进行简化，直接业务层的增删改查方法都不用写了，用到的时候再说把

    1.7、表现层标准开发

    一定要注意分页查询功能是怎么写的，包括用REST风格是怎么访问路径，并且那当前页码，和当前页展示的数据数的。还有做分页查询逻辑的时候，我们前面讲过要做一个分页查询拦截器，要不然就会查出所有的数据

    1. package com.Bivin.controller;
    2.  
    3. import com.Bivin.pojo.Book;
    4. import com.Bivin.service.impl.BookServiceImpl;
    5. import com.baomidou.mybatisplus.core.metadata.IPage;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.*;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  *  表现层业务 -- 基于REST风格
    13.  */
    14.  
    15.  
    16. @RestController // @Controller和@ResponseBody注解 （表现层bean注解和响应前端数据注解）
    17. @RequestMapping(value = "/books")   // 访问路径
    18. public class BookController {
    19.     /**
    20.      *  表现层和业务层之间的依赖关系
    21.      *  通过自动装配获取到业务层对象，然后调用业务层的增删改查等功能
    22.      */
    23.     @Autowired
    24.     private BookServiceImpl bookService;    // 这里注入接口或者实现接口类都可以（习惯注入实现接口类，更好理解）
    25.  
    26.  
    27.     /**
    28.      *  1、查询所有功能访问路径
    29.      */
    30.  
    31.     @GetMapping  // REST风格简化method行为（忘记的话看笔记）
    32.     public List selectAll(){
    33.  
    34.         // 调用业务层查询所有功能
    35.         List books = bookService.selectAll();
    36.         return books;   // 响应给前端数据 （直接return即可）
    37.     }
    38.  
    39.     /**
    40.      * 2、添加功能
    41.      */
    42.  
    43.     @PostMapping
    44.     public boolean save(@RequestBody Book book){    // @RequestBody注解： 接收的是json格式数据 （忘记的话看笔记）
    45.  
    46.         // 调用业务层添加功能
    47.         return bookService.save(book);
    48.     }
    49.  
    50.     /**
    51.      * 3、修改功能
    52.      */
    53.     @PutMapping
    54.     public boolean update(@RequestBody Book book){
    55.  
    56.         // 调用业务层修改功能
    57.         return bookService.update(book);
    58.     }
    59.  
    60.     /**
    61.      * 4、删除功能 （通过id删除数据）
    62.      */
    63.  
    64.     @DeleteMapping(value = "/{id}")
    65.     public boolean delete(@PathVariable Integer id){
    66.  
    67.         // 调用业务层的删除功能
    68.         return bookService.delete(id);
    69.     }
    70.  
    71.     /**
    72.      *  5、通过id查询单条数据功能
    73.      */
    74.     @GetMapping(value = "/{id}")
    75.     public Book selectById(@PathVariable Integer id){
    76.  
    77.         // 调用业务层的通过id查询单条数据功能
    78.         return bookService.selectById(id);
    79.     }
    80.  
    81.     /**
    82.      *  6、分页查询功能
    83.      *
    84.      *      int currentPage：代表前端想要查询第几页的数据
    85.      *      int pageSize ： 代表该页展示的数据数 （比如：第五页，该页展示5条数据）
    86.      *
    87.      *
    88.      */
    89.  
    90.     @GetMapping(value = "/{currentPage}/{pageSize}")
    91.     public IPage getByPage(@PathVariable int currentPage, @PathVariable int pageSize){
    92.  
    93.         // 调用业务层分页查询功能
    94.         return bookService.getByPage(currentPage,pageSize);
    95.  
    96.     }
    97. }

    开启服务器后，前端访问分页查询功能的格式是如下所示格式：

     通过日志我们也可以看出确实拿到了数据库中的第一页中的五条数据了：

    1.8、把表现层响应给前端的true/false做一些标识码返回给前端用户

    我们知道，客户端通过访问表现层BookController的增删改查的方法，
    *          最终调用完增删改查方法拿到结果是我们返回的true或者false、要么就是查询出来的数据
    *
    *          前端人就开始找事了：说你返回给我的true到底是修改功能返回的true还是增加功能返回的true啊
    *          所以为了解决事B，我们用一个类专门封装查询出来的数据，并且标记好状态码（比如1：表示成功，2：表示失败）
    *
    *          注意：该类的写法在实际开发中，是前后端商量出来的协议，就是说前后端程序员商量好后端的数据以什么样的格式返回给前端

     Result类：

    1. package com.Bivin.controller;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  *      分析该类的作用：
    7.  *
    8.  *          我们知道，客户端通过访问表现层BookController的增删改查的方法，
    9.  *          最终调用完增删改查方法拿到结果是我们返回的true或者false、要么就是查询出来的数据
    10.  *
    11.  *          前端人就开始找事了：说你返回给我的true到底是修改功能返回的true还是增加功能返回的true啊
    12.  *          所以为了解决事B，我们用一个类专门封装查询出来的数据，并且标记好状态码（比如1：表示成功，2：表示失败）
    13.  *
    14.  *          注意：该类的写法在实际开发中，是前后端商量出来的协议，就是说前后端程序员商量好后端的数据以什么样的格式返回给前端
    15.  **/
    16.  
    17. @Data   // lombok快速开发实体类（ 自动帮我们写好setter getter toString方法了 ）
    18. public class Result {
    19.  
    20.     private Object data;    // 封装结果数据 （用Object万能,返回给前端数据的时候，可以把表现层获取到的所有类型的数据，如Book类型、查询所有功能返回的List集合类型的数据，都可以封装到Object类型的属性当中，然后返回响应给前端人员）
    21.     private Integer code;   // 标记状态码（比如1：表示成功，2：表示失败）
    22.     private String msg;     // 消息（比如说：调用增删改查功能失败了，返回给前端一句话让前端知道失败了）
    23.  
    24.     // 把构造方法的几种情况都写出来（因为表现层响应给前端数据的时候，不一定这三个属性都用得到，有可能就用两个参数的构造方法，有可能用三个参数的构造方法）
    25.  
    26.     public Result(Object data, Integer code) {
    27.         this.data = data;
    28.         this.code = code;
    29.     }
    30.  
    31.     public Result(Object data, Integer code, String msg) {
    32.         this.data = data;
    33.         this.code = code;
    34.         this.msg = msg;
    35.     }
    36.  
    37.     public Result(Integer code) {
    38.         this.code = code;
    39.     }
    40. }

    Code类：

    1. package com.Bivin.controller;
    2.  
    3. /**
    4.  *      分析该类的作用：
    5.  *           标记状态码（比如1：表示成功，2：表示失败）的类，（ Result里面的 ）
    6.  *
    7.  *           注意：这些状态码不是固定的，是实际开发中前端程序员和后端程序员商量好规定的一种状态信息，
    8.  *           通过这些商量的状态码，就可以知道拿没拿到数据了
    9.  *
    10.  */
    11.  
    12.  
    13. public class Code {
    14.     /**
    15.      *  调用增删改查功能成功的状态码标记
    16.      *
    17.      *  注：因为是static静态修饰的，所以可以直接用类名Code调用属性名
    18.      *  public修饰：代表公共的（也就是说，任何包下的只要通过类名. 的方式都可以调取到Code类下的属性值）
    19.      *
    20.      */
    21.     public static final Integer SAVE_OK = 20011;
    22.     public static final Integer DELETE_OK = 20021;
    23.     public static final Integer UPDATE_OK = 20031;
    24.     public static final Integer SELECT_OK = 20041;
    25.     public static final Integer SELECTById_OK = 20051;  // 通过id查询成功标识码
    26.     public static final Integer SELECTPage_OK = 20061;  // 分页查询成功标识码
    27.  
    28.  
    29.     /**
    30.      *  调用增删改查功能失败的状态码标记
    31.      */
    32.     public static final Integer SAVE_ERR = 20010;
    33.     public static final Integer DELETE_ERR = 20020;
    34.     public static final Integer UPDATE_ERR = 20030;
    35.     public static final Integer SELECT_ERR = 20040;
    36.     public static final Integer SELECTById_ERR = 20050;  // 通过id查询失败标识码
    37.     public static final Integer SELECTPage_ERR = 20060;  // 分页查询失败标识码
    38.  
    39.  
    40. }

    表现层：

    1. package com.Bivin.controller;
    2.  
    3. import com.Bivin.pojo.Book;
    4. import com.Bivin.service.impl.BookServiceImpl;
    5. import com.baomidou.mybatisplus.core.metadata.IPage;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.*;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  *  表现层业务 -- 基于REST风格
    13.  */
    14.  
    15.  
    16. @RestController // @Controller和@ResponseBody注解 （表现层bean注解和响应前端数据注解）
    17. @RequestMapping(value = "/books")   // 访问路径
    18. public class BookController {
    19.     /**
    20.      *  表现层和业务层之间的依赖关系
    21.      *  通过自动装配获取到业务层对象，然后调用业务层的增删改查等功能
    22.      */
    23.     @Autowired
    24.     private BookServiceImpl bookService;    // 这里注入接口或者实现接口类都可以（习惯注入实现接口类，更好理解）
    25.  
    26.  
    27.     /**
    28.      *  1、查询所有功能访问路径
    29.      */
    30.  
    31.     @GetMapping  // REST风格简化method行为（忘记的话看笔记）
    32.     public Result selectAll(){
    33.  
    34.         // 调用业务层查询所有功能
    35.         List books = bookService.selectAll();
    36.  
    37.         /**
    38.          *  直接判断调用查询所有功能查询出来的是否有数据，有的话封装到Result对象属性中返回给前端数据和成功标识码，还可以再返回一点信息
    39.          */
    40.         // 如果查询出来的数据不为null，就把Code.SELECT_OK查询成功标识码赋给integer变量，然后通过Result对象响应给前端，为null的话就是Code.SELECT_ERR查询失败标识码
    41.         Integer integer = books != null ? Code.SELECT_OK : Code.SELECT_ERR; // books不为null说明查询出来数据了
    42.  
    43.         return new Result(books,integer);   // 把查询出来的数据和上面的成功标识码封装到Result对象属性中响应返回给前端人员
    44.  
    45.     }
    46.  
    47.     /**
    48.      * 2、添加功能
    49.      */
    50.  
    51.     @PostMapping
    52.     public Result save(@RequestBody Book book){    // @RequestBody注解： 接收的是json格式数据 （忘记的话看笔记）
    53.  
    54.         // 调用业务层添加功能
    55.         boolean b = bookService.save(book);
    56.  
    57.         return new Result(b ? Code.SAVE_OK : Code.SAVE_ERR);    // 添加如果成功的话(b为true)响应给前端 Code.SAVE_OK 保存成功标识码即可，否则后者
    58.     }
    59.  
    60.     /**
    61.      * 3、修改功能
    62.      */
    63.     @PutMapping
    64.     public Result update(@RequestBody Book book){
    65.  
    66.         // 调用业务层修改功能
    67.         boolean b = bookService.update(book);
    68.  
    69.         return new Result(b ? Code.UPDATE_OK : Code.UPDATE_ERR);
    70.     }
    71.  
    72.     /**
    73.      * 4、删除功能 （通过id删除数据）
    74.      */
    75.  
    76.     @DeleteMapping(value = "/{id}")
    77.     public Result delete(@PathVariable Integer id){
    78.  
    79.         // 调用业务层的删除功能
    80.         boolean b = bookService.delete(id);
    81.  
    82.         return new Result(b ? Code.DELETE_OK : Code.DELETE_ERR);
    83.     }
    84.  
    85.     /**
    86.      *  5、通过id查询单条数据功能
    87.      */
    88.     @GetMapping(value = "/{id}")
    89.     public Result selectById(@PathVariable Integer id){
    90.  
    91.         // 调用业务层的通过id查询单条数据功能
    92.         Book book = bookService.selectById(id);
    93.  
    94.         Integer integer = book != null ? Code.SELECTById_OK : Code.SELECTById_ERR;  // 判断查询的是否为null，不为null的话拿到查询成功状态码
    95.         String s = book != null ? "查询成功~" : "查询失败~";    // 还可以做一些信息
    96.  
    97.         return new Result(book,integer,s);
    98.  
    99.     }
    100.  
    101.     /**
    102.      *  6、分页查询功能
    103.      *
    104.      *      int currentPage：代表前端想要查询第几页的数据
    105.      *      int pageSize ： 代表该页展示的数据数 （比如：第五页，该页展示5条数据）
    106.      *
    107.      *
    108.      */
    109.  
    110.     @GetMapping(value = "/{currentPage}/{pageSize}")
    111.     public Result getByPage(@PathVariable int currentPage, @PathVariable int pageSize){
    112.  
    113.         // 调用业务层分页查询功能
    114.         IPage page = bookService.getByPage(currentPage, pageSize);
    115.  
    116.         Integer integer = page != null ? Code.SELECTPage_OK : Code.SELECTPage_ERR;
    117.         String s = page != null ? "分页查询成功~" : "分页查询失败~";
    118.  
    119.         return new Result(page,integer,s);
    120.  
    121.     }
    122. }

    开启服务器后，假设前端访问查询所有的功能：

    1.9、项目中的异常处理

    我们在前面ssm异常笔记中讲过（忘记的话看前面笔记），项目中的异常分为业务异常、系统异常、其他异常。

    总的来说就是当客户端访问数据资源的时候出现的一些异常情况，比如下面用户在访问查询所有功能的时候，出现了异常的情况（我们假定在查询所有功能中模拟了异常的存在），也就是说出现异常情况后客户调用该查询所有功能的时候拿不到数据，而是拿到了一些异常出错的信息比如500等，那么客户就说了我tm的访问的这明明是查询所有的功能，这尼玛给我返回的都是什么玩意

    代码演示如下所示：

    前端访问该查询所有功能：（前端看到返回的信息后，直接气的骂街，前端说我们本来商量好的通过标识码返回给我信息和数据的，成功的话就把数据和成功标识码发给我，失败的话就把失败标识码发个我，这尼玛发给我的什么东西，啥也看不懂，也不是我们商量好的成功/失败的状态码）

    因此我们后端需要把一些异常给处理了，毕竟异常大多数都是出于我们后端项目中的，我们总不能明明和前端都商量好了格式：访问资源成功的话就响应给前端相对应的数据和成功的标识码，访问资源失败的话就响应给前端相对应的提示失败信息和失败的标识码，而我们总不能不处理异常当前端访问资源有异常的时候，响应给前端的格式前端人压根都不知道是什么了，因此我们需要把异常处理掉，并且项目中如果真的有异常的情况下，也要把异常的信息通过前端和后端本来商量好的通过标识码的格式响应给前端，毕竟商量过，前端能知道这是怎么回事了（还是需要用到Result封装返回结果的类，和Code ：标识状态码的类）

    下面演示的是其他异常的处理方式：

     思考：我们后端该怎么处理上面这个异常呢：

    第一步：写异常处理器 （忘记的话看前面异常的笔记）

    注1：因为不管是数据层出现的异常还是业务层出现的异常最终都会上抛到表现层中，所以异常处理器基本上都写在表现层中

    处理完异常后前端在访问查询所有功能的时候（此功能中有异常的存在）：

     补充能量：再理解：

    上面我们处理的异常类型是其他异常，我们知道还有两个异常种类：业务异常和系统异常，

    这两个异常的处理方式其实就是写个业务异常类或者系统异常类，把异常的信息封装到业务异常类属性中或者系统异常类属性中，然后再通过异常处理器的拦截后返回响应给前端业务异常类或者系统异常类属性中封装的那些异常数据即可，其实三种处理方式都是一样的，只不过业务异常和系统异常有个专门的类用来做桥梁

    2.0、条件查询（重）

    表现层代码逻辑：

    业务层的代码逻辑：

     数据的访问方式：

    2.1、前端页面调用

    注：前端代码不再展示

     

  • 相关阅读:
    GitHub+Hexo博客搭建
    【数据结构练习】二叉树相关oj题集锦二
    《Redis设计与实现》笔记
    KingbaseES例程之拥有大量索引的表导入数据
    学习java的第十九天。。。（方法重写、Object类）
    有趣的前端知识（三）
    0基础python全栈教程前言，0基础学习python难不难
    《DevOps 精要:业务视角》- 读书笔记（二）
    初学C语言，写给自己的第一个实用程序
    桥接模式简介
  • 原文地址：https://blog.csdn.net/lwj_07/article/details/126155532