• Java的基础框架之MyBatisPlus(SpringBoot整合MyBatisPlus和乐观锁)

    MyBatisPlus

    MyBatisPlus

    MyBatisPlus简介

    SpringBoot整合MyBatisPlus

    1. 创建新模块，选择Spring初始化，并配置模块相关基础信息

      创建新模块1

      创建新模块2

    2. 选择当前模块需要使用的技术集（仅保留JDBC）

      选择技术集

    3. 手动添加MyBatisPlus起步依赖
      <dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.4.1version>
dependency>
<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.16version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      注意

      由于mp并未被收录到idea的系统内置配置，无法直接选择加入

      如果使用Druid数据源，需要导入对应坐标

    4. 制作实体类与表结构

      （类名与表名对应，属性名与字段名对应）

    5. 设置Jdbc参数（application.yml）
      spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC
    username: root
    password: root

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
    6. 定义数据接口，继承BaseMapper
      package com.baiyang.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.domain.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserDao extends BaseMapper<User> {
}


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
    7. 测试类中注入dao接口，测试功能
      package com.baiyang;

import com.baiyang.dao.UserDao;
import com.baiyang.domain.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22

    MyBatisPlus概述

    MyBatis介绍
    MyBatisPlus特性
    • 无侵入：只做增强不做改变，不会对现有工程产生影响
    • 强大的 CRUD 操作：内置通用 Mapper，少量配置即可实现单表CRUD 操作
    • 支持 Lambda：编写查询条件无需担心字段写错
    • 支持主键自动生成
    • 内置分页插件

    标准数据层开发

    MyBatisPlus的CRUD操作

    MyBatisPlus的CRUD操作

    package com.itheima;

import com.itheima.dao.UserDao;
import com.itheima.domain.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testSave() {
        User user = new User();
        user.setName("白杨");
        user.setPassword("baiyang");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }

    @Test
    void testDelete() {
        userDao.deleteById(1401856123725713409L);
    }

    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Tom888");
        user.setPassword("tom888");
        userDao.updateById(user);
    }

    @Test
    void testGetById() {
        User user = userDao.selectById(2L);
        System.out.println(user);
    }


    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    Lombok插件介绍

    • Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发。
    <dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.12version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    • 常用注解

      @Data，为当前实体类在编译期设置对应的get/set方法，无参/无参构造方法，toString方法，hashCode方法，equals方法等

    package com.baiyang.domain;

import lombok.*;
/*
    1 生成getter和setter方法：@Getter、@Setter
      生成toString方法：@ToString
      生成equals和hashcode方法：@EqualsAndHashCode

    2 统一成以上所有：@Data

    3 生成空参构造： @NoArgsConstructor
      生成全参构造： @AllArgsConstructor

    4 lombok还给我们提供了builder的方式创建对象,好处就是可以链式编程。 @Builder【扩展】
 */
@Data
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    MyBatisPlus分页功能

    分页功能接口

    分页功能接口

    MyBatisPlus分页使用

    1. 设置分页拦截器作为Spring管理的bean

      package com.baiyang.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusConfig {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //1 创建MybatisPlusInterceptor拦截器对象
        MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

    2. 执行分页查询

    //分页查询
@Test
void testSelectPage(){
    //1 创建IPage分页对象,设置分页参数
    IPage<User> page=new Page<>(1,3);
    //2 执行分页查询
    userDao.selectPage(page,null);
    //3 获取分页结果
    System.out.println("当前页码值："+page.getCurrent());
    System.out.println("每页显示数："+page.getSize());
    System.out.println("总页数："+page.getPages());
    System.out.println("总条数："+page.getTotal());
    System.out.println("当前页数据："+page.getRecords());
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    开启MyBatisPlus日志
    spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC
    username: root
    password: root
# 开启mp的日志（输出到控制台）
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    解决日志打印过多问题
    取消初始化spring日志打印

    取消初始化spring日志打印

    做法

    在resources下新建一个logback.xml文件，名称固定

    
<configuration>

configuration>

    • 1
    • 2
    • 3
    • 4

    关于logback参考

    https://www.jianshu.com/p/75f9d11ae011

    取消SpringBoot启动banner图标

    取消初始化spring日志打印

    spring:
  main:
    banner-mode: off # 关闭SpringBoot启动图标(banner)

    • 1
    • 2
    • 3
    取消MybatisPlus启动banner图标

    取消MybatisPlus启动banner图标

    # mybatis-plus日志控制台输出
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    banner: off # 关闭mybatisplus启动图标

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    DQL编程控制

    条件查询方式

    MyBatisPlus将书写复杂的SQL查询条件进行了封装，使用编程的形式完成查询条件的组合

    条件查询方式

    条件查询
    按条件查询
    //方式一：按条件查询
QueryWrapper<User> qw=new QueryWrapper<>();
qw.lt("age", 18);
List<User> userList = userDao.selectList(qw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    lambda格式按条件查询
    //方式二：lambda格式按条件查询
QueryWrapper<User> qw = new QueryWrapper<User>();
qw.lambda().lt(User::getAge, 10);
List<User> userList = userDao.selectList(qw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    lambda格式按条件查询
    //方式三：lambda格式按条件查询
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.lt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    组合条件
    并且关系（and）
    //并且关系
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//并且关系：10到30岁之间
lqw.lt(User::getAge, 30).gt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    或者关系（or）
    //或者关系
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//或者关系：小于10岁或者大于30岁
lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    NULL值处理
    if语句控制条件追加
    Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
if(minAge!=null){
    lqw.gt(User::getAge, minAge);
}
if(maxAge!=null){
    lqw.lt(User::getAge, maxAge);
}
List<User> userList = userDao.selectList(lqw);
userList.forEach(System.out::println);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    条件参数控制
    Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//参数1：如果表达式为true，那么查询才使用该条件
lqw.gt(minAge!=null,User::getAge, minAge);
lqw.lt(maxAge!=null,User::getAge, maxAge);
List<User> userList = userDao.selectList(lqw);
userList.forEach(System.out::println);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    条件参数控制（链式编程）
    Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//参数1：如果表达式为true，那么查询才使用该条件
lqw.gt(minAge!=null,User::getAge, minAge)
   .lt(maxAge!=null,User::getAge, maxAge);
List<User> userList = userDao.selectList(lqw);
userList.forEach(System.out::println);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    查询投影-设置【查询字段、分组、分页】

    查询结果包含模型类中部分属性
    /*LambdaQueryWrapper lqw = new LambdaQueryWrapper();
lqw.select(User::getId, User::getName, User::getAge);*/
//或者
QueryWrapper<User> lqw = new QueryWrapper<User>();
lqw.select("id", "name", "age", "tel");
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    查询结果包含模型类中未定义的属性
    QueryWrapper<User> lqw = new QueryWrapper<User>();
lqw.select("count(*) as count, tel");
lqw.groupBy("tel");
List<Map<String, Object>> userList = userDao.selectMaps(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5

    查询条件设定

    查询条件
    • 用户登录（eq匹配）
    LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//等同于=
lqw.eq(User::getName, "Jerry").eq(User::getPassword, "jerry");
User loginUser = userDao.selectOne(lqw);
System.out.println(loginUser);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 购物设定价格区间、户籍设定年龄区间（le ge匹配 或 between匹配）
    LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//范围查询 lt le gt ge eq between
lqw.between(User::getAge, 10, 30);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 查信息，搜索新闻（非全文检索版：like匹配）
    LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//模糊匹配 like
lqw.likeLeft(User::getName, "J");
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 统计报表（分组查询聚合函数）
    QueryWrapper<User> qw = new QueryWrapper<User>();
qw.select("gender","count(*) as nums");
qw.groupBy("gender");
List<Map<String, Object>> maps = userDao.selectMaps(qw);
System.out.println(maps);

    • 1
    • 2
    • 3
    • 4
    • 5
    查询API

    字段映射与表名映射

    表字段与编码属性设计不同步

    在模型类属性上方，使用@TableField属性注解，通过value属性，设置当前属性对应的数据库表中的字段关系

    表字段与编码属性设计不同步

    编码中添加了数据库中未定义的属性

    在模型类属性上方，使用@TableField注解，通过exist属性，设置属性在数据库表字段中是否存在，默认为true。此属性无法与value合并使用

    编码中添加了数据库中未定义的属性

    采用默认查询开放了更多的字段查看权限

    在模型类属性上方，使用@TableField注解，通过select属性：设置该属性是否参与查询。此属性与select()映射配置不冲突

    采用默认查询开放了更多的字段查看权限

    表名与编码开发设计不同步

    在模型类上方，使用@TableName注解，通过value属性，设置当前类对应的数据库表名称

    表名与编码开发设计不同步

    @Data
@TableName("tbl_user")
public class User {
    /*
        id为Long类型，因为数据库中id为bigint类型，
        并且mybatis有自己的一套id生成方案，生成出来的id必须是Long类型
     */
    private Long id;
    private String name;
    @TableField(value = "pwd",select = false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist = false) //表示online字段不参与CRUD操作
    private Boolean online;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    DML编程控制

    id生成策略控制（Insert）

    id生成策略控制（@TableId注解）

    • 名称

      @TableId

    • 类型

      属性注解

    • 位置

      模型类中用于表示主键的属性定义上方

    • 作用

      设置当前类中主键属性的生成策略

    • 相关属性

      type

      设置主键属性的生成策略，值参照IdType枚举值

      id生成策略控制

    全局策略配置
    mybatis-plus:
  global-config:
    db-config:
      id-type: assign_id
      table-prefix: tbl_

    • 1
    • 2
    • 3
    • 4
    • 5
    id生成策略全局配置

    id生成策略全局配置

    表名前缀全局配置

    《同上》

    多记录操作

    按照主键删除多条记录
    //删除指定多条数据
List<Long> list = new ArrayList<>();
list.add(1402551342481838081L);
list.add(1402553134049501186L);
list.add(1402553619611430913L);

userDao.deleteBatchIds(list);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    根据主键查询多条记录
    //查询指定多条数据
List<Long> list = new ArrayList<>();
list.add(1L);
list.add(3L);
list.add(4L);
userDao.selectBatchIds(list);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    逻辑删除（Delete/Update）

    逻辑删除实例
    1. 数据库表中添加逻辑删除标记字段
    2. 实体类中添加对应字段，并设定当前字段为逻辑删除标记字段
      package com.baiyang.domain;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;

@Data
public class User {

    private Long id;
    
    //逻辑删除字段，标记当前记录是否被删除
    @TableLogic
    private Integer deleted;
    
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
    3. 配置逻辑删除字面值
      mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除字面值：未删除为0
      logic-not-delete-value: 0
      # 逻辑删除字面值：删除为1
      logic-delete-value: 1

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      逻辑删除本质

      逻辑删除的本质其实是修改操作。如果加了逻辑删除字段，查询数据时也会自动带上逻辑删除字段

      执行的SQL语句

      update 表名 set 逻辑删除标记字段=改变后的字段 where id=？ and 逻辑删除标记字段=原字段

    乐观锁（Update）

    乐观锁实例
    1. 数据库表中添加锁标记字段
    2. 实体类中添加对应字段，并设定当前字段为逻辑删除标记字段
      package com.baiyang.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

@Data
public class User {

	private Long id;
	
    @Version
    private Integer version;
}


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
    3. 配置乐观锁拦截器实现锁机制对应的动态SQL语句拼装
      package com.baiyang.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();

        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        
        return mpInterceptor;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
    4. 使用乐观锁机制在修改前必须先获取到对应数据的verion方可正常进行
      @Test
public void testUpdate() {
    /*User user = new User();
    user.setId(3L);
    user.setName("Jock666");
    user.setVersion(1);
    userDao.updateById(user);*/
    
    //1.先通过要修改的数据id将当前数据查询出来
    //User user = userDao.selectById(3L);
    //2.将要修改的属性逐一设置进去
    //user.setName("Jock888");
    //userDao.updateById(user);
    
    //1.先通过要修改的数据id将当前数据查询出来
    User user = userDao.selectById(3L);     //version=3
    User user2 = userDao.selectById(3L);    //version=3
    user2.setName("Jock aaa");
    userDao.updateById(user2);              //version=>4
    user.setName("Jock bbb");
    userDao.updateById(user);               //verion=3?条件还成立吗？
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      注意

      执行修改前先执行修改语句

      执行修改时使用

      update 表名 set 修改的所有字段 where id=？ and 乐观锁字段=？

  • 相关阅读:
    Redis的各种部署
    PWC光流估计网络
    Sui上低Gas费为预言机注入强大动力
    【Git】git commit -m 提交信息约束规范
    Opengl ES之YUV数据渲染
    python调用c++动态库
    R语言探索与分析17-股票题目
    Faiss原理和使用总结
    视频生成模型Sora的全面解析：从AI绘画、ViT到ViViT、DiT、VDT、NaViT、VideoPoet
    手工计算深度学习模型是如何更新参数的
  • 原文地址：https://blog.csdn.net/weixin_48548208/article/details/126695530