MybatisPlus（MP）使用&知识点笔记

2024-03-02 21:19:58

MP使用&知识点笔记
一、环境搭建
1.创建SpringBoot工程
Springboot场景启动器版本以2.2.1.RELEASE为例；
2.导入依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.3.1</version>
    </dependency>
    <!--简化实体类-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.18</version>
    </dependency>
    <!--Mysql依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

3.在application.yml 进行数据库连接配置:

# DataSource Config
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 1234
    url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
    #    url: jdbc:mysql://localhost:3306/mybatis_plus      # 更高版本
# mybatis日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

4.在主启动类添加@MapperScan 注解，扫描 Mapper 文件夹

@SpringBootApplication
@MapperScan("com.mapper")
public class DemomptestApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemomptestApplication.class, args);
    }

}

5.添加实体类
并提供构造法方法;

6.添加mapper
创建包 mapper 编写Mapper 接口： XXXMapper.java

@Repository
public interface UserMapper extends BaseMapper<User> {
}

在这里extends 了 BaseMapper 并指定了类型
BaseMapper 内封装了一些对DAO的一些基本的操作
注意:为了避免报错（IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。）；可以在 dao 层的接口上添加 @Repository 注解

7.测试
MP封装的有基本的操作的方法,因此便可以使用直接对Dao进行基本操作
编写测试类:
查询操作：

@SpringBootTest
class DemomptestApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void findAll() {
        List<User> users = userMapper.selectList(null);
        System.out.println(users);
    }
}

添加操作：

//添加
@Test
public void testAdd() {
    User user = new User();
    user.setName("lucy");
    user.setAge(20);
    user.setEmail("1243@qq.com");
    int insert = userMapper.insert(user);
    System.out.println(insert);
}

重点：数据库插入id值默认为：全局唯一id

二、知识点：

1.MP的主键生成策略：
MyBatis-Plus默认的主键策略是：ASSIGN_ID （使用了雪花算法）
1.1 ASSIGN_ID

@TableId(type = IdType.ASSIGN_ID)
private String id;
雪花算法：分布式ID生成器
雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。
优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高


1.2	AUTO 自增策略
需要在创建数据表的时候设置主键自增
不设置主键自增,会报id的value没有默认值
实体字段中配置 @TableId(type = IdType.AUTO)```

```java
@TableId(type = IdType.AUTO)
private Long id;

要想影响所有实体的配置，可以设置全局主键配置

#全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=auto

2.自动填充和乐观锁
2.1.1 更新操作
update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=?

//修改
@Test
public void testUpdate() {
    User user = new User();
    user.setId(1340868235401764865L);
    user.setName("lucymary");
    int count = userMapper.updateById(user);
    System.out.println(count);
}

2.1.2 自动填充
需求描述：
项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。

我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作

2.1.3数据库修改
①在User表中添加datetime类型的新的字段 create_time、update_time

②实体上增加字段并添加自动填充注解

@TableField(fill = FieldFill.INSERT)
private Date createTime;  //create_time

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime; //update_time

③实现元对象处理器接口
注意：不要忘记添加 @Component 注解

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    
    //mp执行添加操作，这个方法执行
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
    
    //mp执行修改操作，这个方法执行
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

2.2 乐观锁
是解决某些问题的解决方法，（当多个用户同时操作同一条数据时，会会造成“丢失更新”（指用户1、用户2都拿到数据后，用户1更改数据后，而用户2拿到的将不是新数据=错误数据，），那么就可以用MP实现乐观锁来解决丢失更新问题）

乐观锁实现方式：
取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败
在Mybatis-Plus项目中，使用乐观锁：

①首先在数据库表中添加version字段指定int类型
②在实体类里添加

@Version
private Integer version;

③创建配置文件

创建包config，创建文件MybatisPlusConfig.java
此时可以删除主类中的 @MapperScan 扫描注解

@Configuration
@MapperScan("com.mapper")
public class MpConfig {
    /**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

测试：
测试数据version字段不可为null
version为null的话乐观锁不会生效（条件将不附带查询时的version版本，与当前version版本）
①配置version版本在添加新数据时就同时给version加值
①.①：在实体version字段添加自动填充注解：@TableField(fill = FieldFill.INSERT)

@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;

①.②:再在实现元对象处理器接口中的添加方法中添加：
this.setFieldValByName(“version”, 1, metaObject);

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    //mp执行添加操作，这个方法执行
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
        this.setFieldValByName("version", 1, metaObject);
    }

    //mp执行修改操作，这个方法执行
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

②查询后修改数据

@Test
public void testOptimisticLocker(){
    // 根据id查询
    User user = userMapper.selectById(1397374683537256452L);
    // 修改
    user.setName("张三");
    // 应为已经配置了乐观锁,mp已经帮我们做了,因此不需要更新version
    userMapper.updateById(user);
}

③它的底层是有对version字段进行查询，修改操作时where条件会附带比较version是否和查询时的版本是否一致，一致则继续执行，不一致，将不会执行更改操作；

1、查询

// 多个ID批量查询
@Test
public void testSelect1(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    System.out.println(users);
}

通过map封装查询条件
注意：map中的key对应数据库中的列名。如：数据库user_id,实体类是userId,这时map的key需要填写user_id；

// 封装简单条件查询
@Test
public void  testSelect2(){
    HashMap<String, Object> columnMap = new HashMap<>();
    columnMap.put("name","Jone");
    columnMap.put("email","test1@baomidou.com");
    List<User> users = userMapper.selectByMap(columnMap);

    System.out.println(users);
}

MyBatis Plus 自带分页插件,但要简单的配置即可实现分页功能
添加分页插件


@Configuration
@MapperScan("com.mapper")
public class MybatisPlusConfig {

    /**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
    /**
     * 分页插件
     */
    public PaginationInterceptor paginationInterceptor(){

        return new PaginationInterceptor();
    }

}

测试selectPage分页
测试:通过page对象获取相关数据

// 分页查询
@Test
public void testSelectPage(){
    Page<User> page = new Page(1,3);

    Page<User> userPage = userMapper.selectPage(page, null);

    //返回对象得到分页所有数据
    long pages = userPage.getPages(); //总页数
    long current = userPage.getCurrent(); //当前页
    List<User> records = userPage.getRecords(); //查询数据集合
    long total = userPage.getTotal(); //总记录数
    boolean hasNext = userPage.hasNext();  //下一页
    boolean hasPrevious = userPage.hasPrevious(); //上一页
    System.out.println(pages);
    System.out.println(current);
    System.out.println(records);
    System.out.println(total);
    System.out.println(hasNext);
    System.out.println(hasPrevious);

}

测试selectMapsPage分页
当指定了特定的查询列时，希望分页结果列表只返回被查询的列，而不是很多null值
测试selectMapsPage分页：结果集是Map

@Test
public void testSelectMapsPage() {
    //Page不需要泛型
    Page<Map<String, Object>> page = new Page<>(1, 5);
    Page<Map<String, Object>> pageParam = userMapper.selectMapsPage(page, null);
    List<Map<String, Object>> records = pageParam.getRecords();
    records.forEach(System.out::println);
    System.out.println(pageParam.getCurrent());
    System.out.println(pageParam.getPages());
    System.out.println(pageParam.getSize());
    System.out.println(pageParam.getTotal());
    System.out.println(pageParam.hasNext());
    System.out.println(pageParam.hasPrevious());
}

删除与逻辑删除

根据id删除数据(不建议使用)

@Test
public void testDeleteById(){
    int i = userMapper.deleteById(5L);
    System.out.println("testDeleteById执行的条数："+ i);
}

批量删除

简单条件删除

@Test   // 简单条件删除
public void testDeleteByMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Tom");
    map.put("email", "Tomdelete@qq.com");
    int i = userMapper.deleteByMap(map);
    System.out.println("批量删除 执行的条数:" + i);
}

逻辑删除 (建议使用)
物理删除和逻辑删除
物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

1、逻辑删除实现流程
数据库修改添加deleted字段

ALTER TABLE `user` ADD COLUMN `deleted` boolean DEFAULT false

2、实体类修改

@TableLogic
private Integer deleted;

3、配置（可选）
application.properties 加入以下配置，此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

或application.yml配置

# mybatis日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      logic-delete-value: 1
      logic-not-delete-value: 0

测试
测试后发现，数据并没有被删除，deleted字段的值由0变成了1
测试后分析打印的sql语句，是一条update
注意：被删除前，数据的deleted 字段的值必须是 0，才能被选取出来执行逻辑删除的操作

@Test   // 逻辑删除
public void testLogicDelete(){
    int i = userMapper.deleteById(1L);
    System.out.println("批量删除 执行的条数:" + i );
}

条件构造器和常用接口

1、wapper介绍

Wrapper ：条件构造抽象类，最顶端父类
AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
QueryWrapper ：查询条件封装
UpdateWrapper ： Update 条件封装
AbstractLambdaWrapper ：使用Lambda 语法
LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
LambdaUpdateWrapper ： Lambda 更新封装Wrapper

@SpringBootTest
public class QueryWrapperTests {
 
@Autowired
private UserMapper userMapper;
}

2、测试用例
2.1 ge、gt、le、lt、isNull、isNotNull

@Test
public void testQuery() {
QueryWrapper<User>queryWrapper = newQueryWrapper<>();
queryWrapper
        .isNull("name")
        .ge("age", 12)
        .isNotNull("email");
    int result = userMapper.delete(queryWrapper);
System.out.println("delete return count = " + result);
}

2.2 eq、ne
注意：seletOne()返回的是一条实体记录，当出现多条时会报错

@Test
public void testSelectOne() {
QueryWrapper<User>queryWrapper = newQueryWrapper<>();
queryWrapper.eq("name", "Tom");
Useruser = userMapper.selectOne(queryWrapper);//只能返回一条记录，多余一条则抛出异常
System.out.println(user);
}

2.3 between、notBetween
包含大小边界

@Test
public void testSelectCount() {
QueryWrapper<User>queryWrapper = newQueryWrapper<>();
queryWrapper.between("age", 20, 30);
    Integer count = userMapper.selectCount(queryWrapper); //返回数据数量
System.out.println(count);
}

2.4 like、notLike、likeLeft、likeRight
selectMaps()返回Map集合列表，通常配合select()使用

@Test
public void testSelectMaps() {
QueryWrapper<User>queryWrapper = newQueryWrapper<>();
queryWrapper
        .select("name", "age")
        .like("name", "e")
        .likeRight("email", "5");
List<Map<String, Object>>maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
maps.forEach(System.out::println);
}

2.5 orderBy、orderByDesc、orderByAsc

@Test
public void testSelectListOrderBy() {
QueryWrapper<User>queryWrapper = newQueryWrapper<>();
queryWrapper.orderByDesc("age", "id");
List<User>users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}

1、查询方式

码农公寓

二、知识点：

条件构造器和常用接口

相关文章