• Mybatis-plus 使用

    1. 注解使用

            mybatis-plus提供了 ·@TableName·, @TableId, @TableField, @TableLogic 四种注解，其含义分别为：

     @TableName

             @TableName("SPF_Require_Vehicle")    用于声明当前class所对应数据库中的表，如果class的名字和表的名字完全相同，则不需要添加该注解，如果不一样，则需要用该注解进行声明。

     @TableId

            @TableId(value = "SPF_UID", type = IdType.AUTO)     用于声明主键， value指定数据库中主键的名称，type为主键的生成类型，支持 Assign（雪花算法，java字段需要是Long）、Auto（数据库字段需要声明为auto_increment）， uuid

      @TableField

            @TableField("SPF_Name")  用于声明当前字段对应的表中的字段

      @TableLogic

            @TableLogic(value = "0", delval = "1")   用于软删除，value是默认值，delval表示软删除后的值。

    1. @TableName("SPF_Require_Vehicle")
    2. @Data
    3. public class Employee {
    4.     /**
    5.      * 指定主键名称为SPF_uid, 类型为自增，即数据库的字段必须是auto_increment
    6.      */
    7.     @TableId(value = "SPF_UID", type = IdType.AUTO)
    8.     private Long id;
    9.  
    10.     /**
    11.      * 指定数据库中对应的字段是 Part_PartSap
    12.      */
    13.     @TableField("Part_PartSap")
    14.     private String partSap;
    15.  
    16.     @TableField("Part_PlateSap")
    17.     private String plateSap;
    18.  
    19.     @TableField("SPF_Name")
    20.     private String name;
    21.  
    22.     /**
    23.      * 逻辑删除
    24.      */
    25.     @TableLogic(value = "0", delval = "1")
    26.     @TableField("IsActvie")
    27.     private Boolean active;
    28. }

    @EnumValue

            代码简洁性考虑：许多时候需要用到Enum，例如0表示男1表示女、0表示关闭1表示打开，and so on

    1.          在数据库表中增加字段gender： 0表示男，1表示女
    2.           定义枚举类， @EnumValue注解表示该字段是向数据库中插入的值，@JsonValue表示读取的时候对外展示的值        
    1. @Getter
    2. public enum SexEnum {
    3.     SEX_MALE(0, "男"),
    4.     SEX_FEMALE(1, "女");
    5.  
    6.     /**
    7.      * 表示当前字段是执行insert时向数据库中插入的字段
    8.      */
    9.     @EnumValue
    10.     private int sexVal;
    11.  
    12.     /**
    13.      * 表示从数据库读取的时候对外显示的值
    14.      */
    15.     @JsonValue
    16.     private String sexName;
    17.  
    18.     SexEnum(int sexVal, String sexName) {
    19.         this.sexVal = sexVal;
    20.         this.sexName = sexName;
    21.     }
    22.  
    23.     /**
    24.      * 配合 @JsonValue使用
    25.      * @return 返回展示的值
    26.      */
    27.     @Override
    28.     public String toString() {
    29.         return this.sexName;
    30.     }
    31. }

            3.  使用处

                     

                    

             插入的值为枚举注释的值

            读取的是 @JsonValue注释的值

             

    2. IService使用

    2.1 批量插入

    boolean saveBatch(Collection entityList, int batchSize);
    1. @Test
    2.     public void baseBatchInsertTest() {
    3.         List list = new ArrayList<>();
    4.         for (int i = 20; i < 30; i++) {
    5.             Employee employee = new Employee();
    6.             employee.setName("zhagnsan" + i);
    7.             employee.setPartSap("123425-" + i);
    8.             employee.setPlateSap("312342-" + i);
    9.             list.add(employee);
    10.         }
    11.         // 批量插入，service提供了两个函数，可以带第二个参数，也可以不带，不带的情况下默认是1000
    12.         // 批量插入实际也是一条一条的插入，不同的是底层启动了同一个session，插入完成后关闭，不需要每次都开启关闭
    13.         this.service.saveBatch(list, 10);
    14.     }

    2.2 批量插入修改

            如果主键Id已经在表中存在则修改，如果不存在则插入一条新数据

     // 第二个参数选填，默认是1000

    boolean saveOrUpdateBatch(Collection entityList, int batchSize);
    1. @Test
    2.     public void testBatchInsertOrUpdate() {
    3.         List list = new ArrayList<>();
    4.         Employee e1 = new Employee();
    5.         // 1L已经存在，会指定update
    6.         e1.setId(1L);
    7.         // 只添加了一个字段，也就是只修改一个字段
    8.         e1.setName("车轱辘");
    9.         Employee e2 = new Employee();
    10.         // id在表中不存在，则新增
    11.         e2.setId(50L);
    12.         e2.setName("车顶");
    13.         e2.setPartSap("123142314-00");
    14.         e2.setPlateSap("423414-09");
    15.         list.add(e1);
    16.         list.add(e2);
    17.         this.service.saveOrUpdateBatch(list,2);
    18.     }

    2.2 单个插入修改

           // 如果id存在则修改，否则插入

    boolean saveOrUpdate(T entity);

    2.3 单个删除

    default boolean removeById(Serializable id)
    default boolean removeById(T entity)
    1. @Test
    2.     public void testRemoveSingle01() {
    3.         /**
    4.          * id如果存在则删除，返回ture，否则返回false
    5.          */
    6.         boolean b = this.service.removeById(9);
    7.         System.out.println("b:" + b);
    8.     }
    9.  
    10.  
    11. /*
    12. * 有的时候，前端传过来的是一个类，此时可以直接调用该函数删除
    13. */
    14. @Test
    15.     public void testRemoveSignle02() {
    16.         Employee employee = new Employee();
    17.         employee.setId(8L);
    18.         this.service.removeById(employee);
    19.     }

    2.4 有条件删除 

            实际中很多情况并不是根据Id进行删除而是根据实际需要进行删除， service也提供了该功能

    removeByMap
    default boolean removeByMap(Map columnMap)

            

    1. /*
    2. * 下面代码执行的语句如下
    3. * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE Part_PlateSap = ? AND Part_PartSap = ? AND IsActvie=0
    4. */
    5. @Test
    6.     public void testRemoveByMap() {
    7.         Map<String, Object> map = new HashMap<>();
    8.         map.put("Part_PartSap", "123425-0");
    9.         map.put("Part_PlateSap", "312342-0");
    10.         this.service.removeByMap(map);
    11.     }
    remove（可根据条件批量删除）

     也可以根据wrapper进行删除，删除的时候使用的是QueryWrapper， Wrapper的用法有很多种，此处只展示in的用法，其他用法下文进行介绍

    default boolean remove(Wrapper queryWrapper)
    1. @Test
    2.     public void testRemove03() {
    3.         QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    4.         List<Long> list = new ArrayList<>();
    5.         list.add(2L);
    6.         list.add(3L);
    7.         list.add(4L);
    8.         wrapper.in(list != null && !list.isEmpty(), "SPF_UID", list);
    9.         /**
    10.          * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE IsActvie=0 AND (SPF_UID IN (?,?,?))
    11.          */
    12.         this.service.remove(wrapper);
    13.     }

    2.5 批量删除

    根据主键批量删除

    removeByIds
    default boolean removeByIds(Collection list)
    1. @Test
    2.     public void testRemoveByIds() {
    3.         List<Long> list = new ArrayList<>();
    4.         list.add(2L);
    5.         list.add(3L);
    6.         list.add(5L);
    7.         /**
    8.          * 根据Ids批量删除
    9.          * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
    10.          */
    11.         this.service.removeByIds(list);
    12.     }
    removeBatchByIds

    采用jdbc批量删除，底层使用for循环逐个删除，这点是和上面函数的区别

    default boolean removeBatchByIds(Collection list, int batchSize)
    1. @Test
    2.     public void testremoveBatchByIds() {
    3.         List<Long> list = new ArrayList<>();
    4.         list.add(2L);
    5.         list.add(3L);
    6.         list.add(5L);
    7.         /**
    8.          * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID=? AND IsActvie=0
    9.          */
    10.         this.service.removeBatchByIds(list, list.size());
    11.     }

    2.6 单个修改：根据Id修改

    default boolean updateById(T entity)
    1. @Test
    2.     public void testupdateById() {
    3.         Employee employee = new Employee();
    4.         employee.setId(8L);
    5.         employee.setName("doris");
    6.         /**
    7.          * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
    8.          */
    9.         this.service.updateById(employee);
    10.     }

    2.7 有条件修改：根据wrapper修改

    default boolean update(Wrapper updateWrapper)
    1. @Test
    2.     public void testupdate() {
    3.         Integer minId = 9;
    4.         Integer maxId = 14;
    5.         String name = "doris";
    6.         String nName = "wangshun";
    7.         LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
    8.         wrapper.gt(minId != null, Employee::getId, minId)
    9.                 .lt(maxId != null, Employee::getId, maxId)
    10.                 .or()
    11.                 .like(name != null && !name.isEmpty(), Employee::getName, name);
    12.         wrapper.set(nName != null && !nName.isEmpty(), Employee::getName, nName);
    13.         /**
    14.          * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE IsActvie=0 AND (SPF_UID > ? AND SPF_UID < ? OR SPF_Name LIKE ?)
    15.          */
    16.         this.service.update(wrapper);
    17.     }

    2.8 批量修改：根据Id修改

    这个方法很使用，实际工作中，都是根据前端传过来的结构体进行修改

    boolean updateBatchById(Collection entityList, int batchSize)
    1. @Test
    2.     public void testupdateBatchById() {
    3.         List<Employee> list = new ArrayList<>();
    4.         Employee e1 = new Employee();
    5.         e1.setId(1L);
    6.         e1.setName("wangwu");
    7.         Employee e2 = new Employee();
    8.         e2.setId(2L);
    9.         e2.setName("wangbaochuan");
    10.         list.add(e1);
    11.         list.add(e2);
    12.         /**
    13.          * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
    14.          */
    15.         this.service.updateBatchById(list, list.size());
    16.  
    17.     }

    2.9 单个查询

            根据Id单个查询

            getById
    1. @Test
    2.     public void testgetById() {
    3.         /**
    4.          * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID=? AND IsActvie=0
    5.          */
    6.         Employee byId = this.service.getById(1);
    7.         System.out.println(byId);
    8.     }
            getOne

              // 根据条件查找时：如果有多个则会抛出异常

            default T getOne(Wrapper queryWrapper)

            

    1. @Test
    2.     public void testgetOne() {
    3.         LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
    4.         String plateSap = "312342-6";
    5.         wrapper.eq(plateSap != null && !plateSap.isEmpty(), Employee::getPlateSap, plateSap);
    6.         /**
    7.          * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
    8.          *  FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (Part_PlateSap = ?)
    9.          */
    10.         Employee one = this.service.getOne(wrapper);
    11.         System.out.println(one);
    12.     }

            

    2.10 批量查询

            listByIds

            

    1. @Test
    2.     public void testlistByIds() {
    3.         List<Long> list = new ArrayList<>();
    4.         list.add(1L);
    5.         list.add(2L);
    6.         list.add(3L);
    7.         List<Employee> employees = this.service.listByIds(list);
    8.         /**
    9.          * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
    10.          */
    11.         employees.forEach(System.out::println);
    12.     }
    list

             

    1. @Test
    2.     public void testList() {
    3.         List<Employee> list = this.service.list();
    4.         /**
    5.          * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
    6.          *  FROM SPF_Require_Vehicle WHERE IsActvie=0
    7.          */
    8.         list.forEach(System.out::println);
    9.     }

    2.11 有条件批量查询

            listByMap

            default List listByMap(Map columnMap)

    1. @Test
    2.     public void testlistByMap() {
    3.         Map<String, Object> map = new HashMap<>();
    4.         map.put("SPF_Name", "wangshun");
    5.         map.put("Part_PlateSap", "312342-20");
    6.         /**
    7.          * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active 
    8.          *  FROM SPF_Require_Vehicle WHERE Part_PlateSap = ? AND SPF_Name = ? AND IsActvie=0
    9.          */
    10.         List<Employee> employees = this.service.listByMap(map);
    11.         employees.forEach(System.out::println);
    12.     }

    list
    default List list(Wrapper queryWrapper)
    1. @Test
    2.     public void testList() {
    3.         LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
    4.         wrapper.like(Employee::getName, "wangshun");
    5.         List<Employee> list = this.service.list(wrapper);
    6.         /**
    7.          *  SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active 
    8.          *      FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
    9.          */
    10.         list.forEach(System.out::println);
    11.     }

    2.12 查询指定列

    getmap

            // 如果查询出过个，则只取第一个

    Map getMap(Wrapper queryWrapper);
    1. @Test
    2.     public void testSelectMap() {
    3.         String name = "wangshun";
    4.         LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
    5.         wrapper.like(!name.isEmpty(), Employee::getName, name);
    6.         /**
    7.          * 只查询这两列，如果同时查询出多行，则只取第一行
    8.          * SELECT Part_PlateSap AS plateSap,Part_PartSap AS partSap FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
    9.          */
    10.         wrapper.select(Employee::getPlateSap, Employee::getPartSap);
    11.         Map<String, Object> map = this.service.getMap(wrapper);
    12.         System.out.println(map);
    13.     }
    listMap

            可查询多行

    1. @Test
    2.     public void testlistMaps() {
    3.         LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
    4.         wrapper.like(Employee::getName, "wangshun");
    5.         /**
    6.          * 只显示这三列
    7.          */
    8.         wrapper.select(Employee::getPartSap, Employee::getPlateSap, Employee::getName);
    9.         List<Map<String, Object>> maps = this.service.listMaps(wrapper);
    10.         for (Map<String, Object> map : maps) {
    11.             System.out.println(map);
    12.         }
    13.     }

            

    default List> listMaps()  如果不见条件则查询所有的行

    2.13 个数查询      

    // 查询表中国有效的总行数
default long count()

    // 根据条件查询行数
default long count(Wrapper queryWrapper)

    2.14 分页查询

            分页查询需要首先注册mybatis-plus的拦截器，配置如下

    1. @Configuration
    2. public class MpConfig {
    3.     @Bean
    4.     public MybatisPlusInterceptor getIntercepter() {
    5.         MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
    6.         mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    7.         return mybatisPlusInterceptor;
    8.     }
    9. }
    1. @Test
    2.     public void testPage01() {
    3.         Page<Employee> page = new Page<>(2, 4);
    4.         LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
    5.         wrapper.like(Employee::getName, "wangshun");
    6.         this.service.page(page, wrapper);
    7.         System.out.println(page);
    8.         // 查询到的内容
    9.         System.out.println("records: " + page.getRecords());
    10.         // 总页数
    11.         System.out.println("pages: " + page.getPages());
    12.         // 当前页数
    13.         System.out.println("current: " + page.getCurrent());
    14.         // 总条目数
    15.         System.out.println("total: " + page.getTotal());
    16.     }

    2.15 SQL分页查询

            许多时候需要手写语句实现分页查询，例如同时从多张表中查询数据，这个时候需要自己写条件。

    01. 在 application.yml中指定mybatis-plus的相关配置，尤其要指定xml的路径，默认在mapper下，本人仍习惯指明位置

    1. mybatis-plus:
    2.   configuration:
    3.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    4.   # 指定mapper.xml所在的位置
    5.   mapper-locations: classpath:/mapper/*.xml

    02. 在Mapper中增加声明

    1.  /**
    2.      * 手写语句实现分页查询
    3.      * @param page 拦截器使用，当前sql中不需要
    4.      * @param employee 查询对象
    5.      * @return 查询结果
    6.      */
    7.     Page<Employee> getEmployeeInfoByPage(@Param("page") Page<Employee> page, @Param("employee") Employee employee);

    03. 添加Mapper对应的xml文件并增加对应的函数

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.ssm01.mapper.EmployeeMapper">
    6.     <resultMap id="baseResultMap" type="com.ssm01.pojo.Employee">
    7.         <result column="SPF_UID" property="id"/>
    8.         <result column="Part_PartSap" property="partSap"/>
    9.         <result column="Part_PlateSap" property="plateSap"/>
    10.         <result column="SPF_Name" property="name"/>
    11.     </resultMap>
    12.     <select id="getEmployeeInfoByPage" resultMap="baseResultMap">
    13.         select * from SPF_Require_Vehicle where SPF_Name = #{employee.name} and IsActvie = 0
    14.     </select>
    15. </mapper>

    04. 在自己的service中增加相应的方法，调用mapper中的函数

  • 相关阅读:
    Zongmu AVM车载环视 Android SDK 简介
    9月第1周榜单丨哔哩哔哩飞瓜数据B站UP主排行榜发布！
    带你一步步看vue-loader编译流程
    Pytorch 中的AverageMeter 造成内存泄漏
    【SQL】595. 大的国家
    强烈 推荐 13 个 Web前端在线代码IDE
    驱动开发，stm32mp157a开发板的led灯控制实验(优化)，使用ioctl函数，让write/read函数的专注读写功能
    Echarts 3D饼图开发
    如何启动Kotlin协程
    互联网大厂女工抑郁症自救指南
  • 原文地址：https://blog.csdn.net/beitian_123/article/details/133588719