MyBatisPlus详解

最新推荐文章于 2024-05-29 16:47:53 发布

Zero摄氏度

最新推荐文章于 2024-05-29 16:47:53 发布

阅读量1.4w

点赞数 12

分类专栏： MyBatisPlus 文章标签： mybatis java 数据库

本文链接：https://blog.csdn.net/m0_56116754/article/details/126231360

版权

MyBatisPlus 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

MyBatisPlus

一、MyBatisPlus概述

为什么要学习？

MyBatisPlus可以节省我们大量工作时间，所有的CRUD代码都可以自动化完成
JPA、tk-mapper、MyBatisPlus
偷懒用的~

简述

官网https://baomidou.com/
为简化开发而生
MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作，BaseMapper
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

二、快速开始体验

官网地址：https://baomidou.com/pages/226c21/#%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B7%A5%E7%A8%8B

步骤

创建数据库

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);
DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

-- 真实开发中，还会有version（乐观锁）、delete（逻辑删除）、gmt_create 、gmt_modified

创建springboot项目

导入依赖

 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

说明：尽量不要同时导入mybatis和mybatis-plus！有版本差异

配置连接数据库

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# mysql8 驱动不同，需要加时区配置

写实体类

package com.qian.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private int age;
    private String email;
}

写mapper接口

package com.qian.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.qian.pojo.User;
import org.springframework.stereotype.Repository;

@Repository    //代表持久层
//在对应的Mapper上面继承基本的类 BaseMapper
public interface UserMapper extends BaseMapper<User> {
    //所有的CRUD操作已经编写完成，不需要编写mapper.xml
}

**在对应的Mapper上面继承基本的类 BaseMapper **

在主启动类上扫描mapper包下所有接口

package com.qian;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//扫描我们的mapper文件夹
@MapperScan("com.qian.mapper")
@SpringBootApplication
public class MybatisPlusApplication {

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

}

然后就可以测试啦，省去了编写mapper.xml的功夫，不用再写crud的重复代码

package com.qian;

import com.qian.mapper.UserMapper;
import com.qian.pojo.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 MybatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        //查询全部用户   参数是一个Wrapper  ，条件构造器，这里我们先不用null
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

三、配置日志

我们所有的sql现在是不可见的，我们希望知道它是怎么执行的，所以我们必须要看日志！

配置日志

# 配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

运行测试，会自动生成日志

==>  Preparing: SELECT id,name,age,email FROM user 
==> Parameters: 
<==    Columns: id, name, age, email
<==        Row: 1, Jone, 18, test1@baomidou.com
<==        Row: 2, Jack, 20, test2@baomidou.com
<==        Row: 3, Tom, 28, test3@baomidou.com
<==        Row: 4, Sandy, 21, test4@baomidou.com
<==        Row: 5, Billie, 24, test5@baomidou.com
<==      Total: 5

四、CRUD扩展

1）插入操作

测试插入

    //测试插入
    @Test
    public void testInsert(){
        User user=new User();
        user.setName("狂神说java");
        user.setAge(3);
        user.setEmail("791172229@qq.com");
        int insert = userMapper.insert(user);
        System.out.println(insert);//1
        System.out.println(user);//User(id=1556204931867017217, name=狂神说java, age=3, email=791172229@qq.com)
        //id会自动填充
    }

主键生成策略

数据库插入的id的默认值为：全局的唯一id，

分布式唯一id生成的方法：

数据库自增ID
UUID生成
snowflake雪花算法
redis生成id

我们所用的mybatis-plus 实现id生成的方式就是雪花算法

雪花算法 ：核心思想是：采用bigint（64bit）作为id生成类型，并将所占的64bit 划分成多段。（Twitter的snowflake算法）

默认全局唯一id

 @TableId(type = IdType.ID_WORKER)

主键自增，我们需要配置主键自增：
- 实体类字段上 @TableId(type = IdType.AUTO)
- 数据库字段一定要是自增
@TableId(type = IdType.INPUT) 设置为手动输入id ，需要手动插入id ，否则就会输出null

2）更新操作

测试更新

//测试更新
    @Test
    public void testUpdate(){
        User user=new User();
        //通过条件自动拼接动态sql
        user.setId(1L);
        user.setName("关注公众号");
        //注意：updateById（）参数是一个 对象！
        int i = userMapper.updateById(user);
        System.out.println(i);



    }

所有的sql都是自动帮你动态配置的！

3)自动填充

创建时间、修改时间！这些操作都应该自动化完成的，我们不希望手动更新！

方式一：数据库级别

在表中新增字段 create_time , update_time, 数据类型为datetime，默认CURRENT_TIMESTAMP，勾选更新
实体类同步
再次进行插入测试

成功更新时间！

（不推荐使用，工作中不允许你修改数据库）

方式二：代码级别

删除数据库中这两个字段的默认值、更新操作
实体类的字段属性上增加注解

//    public enum FieldFill {
//        DEFAULT,
//        INSERT,
//        UPDATE,
//        INSERT_UPDATE;
    
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

编写处理器来处理这个注解

package com.qian.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill");
        //setFieldValByName():String fieldName, Object fieldVal, MetaObject metaObject
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);

    }

    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill...");
        this.setFieldValByName("updateTime",new Date(),metaObject);

    }
}

再次测试插入

4）乐观锁

乐观锁：

顾名思义十分乐观，它总是认为不会出现问题，无论干什么都不去上锁！如果出现了问题，再次更新值测试
悲观锁：十分悲观，它总是认为会出现问题，无论干什么都会上锁！再去操作！

官网解释：

OptimisticLockerInnerInterceptor

当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：

取出记录时，获取当前 version
更新时，带上这个 version
执行更新时， set version = newVersion where version = oldVersion
如果 version 不对，就更新失败

乐观锁：1、先查询。获得当前版本号 version=1
--- A线程
update user set name = "kuangshen",version=version+1
where id = 2 and version=1   --- 更新时要带上这个version
--- 执行更新时，使获得的当前版本的version=new version（一般就是自动加1）
--- 如果此时线程B抢先完成更新，那么version=2，就不是A线程获得到的version号，所以就A就会更新失败

测试

数据库中加上version字段
实体类补充

 @Version  //乐观锁注解
    private int version;

写注册乐观锁的插件

package com.qian.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@MapperScan("com.qian.mapper")
@EnableTransactionManagement   //开启事务管理
@Configuration   //配置类
public class MybatisPlusConfig {
    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

}

测试乐观锁成功和失败

 //测试乐观锁成功
    @Test
    public void testOptimisticLocker(){
        //查询用户信息
        User user = userMapper.selectById(1L);
        //修改用户信息
        user.setName("xqh");
        user.setEmail("791172229@qq.com");
        //执行更新操作
        userMapper.updateById(user);
    }
    //==>  Preparing: UPDATE user SET name=?, age=?, email=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? 会把version带上

    //测试乐观锁失败 多线程下
    @Test
    public void testOptimisticLocker2(){
        //线程1
        User user = userMapper.selectById(2L);
        user.setName("xqh11");
        user.setEmail("791172229@qq.com");
        //模拟另外一个线程执行插队操作
        User user2 = userMapper.selectById(2L);
        user2.setName("xqh22");
        user2.setEmail("791172229@qq.com");

        userMapper.updateById(user2);   //线程1先查询，然后被线程2插队更新。
        userMapper.updateById(user);//有乐观锁，所以更新user1更新失败。数据库中name修改的还是xqh22.“一旦被插队，就更新失败”
    }

5)查询操作

常见查询操作

  //测试查询
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
    //测试查询多个用户
    @Test
    public void testSelectByBatchId(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }
    //条件查询 map
    @Test
    public void testSelectByMap(){

        HashMap<String,Object> map = new HashMap<>();
        //自定义要查询
        map.put("name","xqh");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);


    }

    //查询数据库中所有信息
    @Test
    public void testSelectList(){

        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

分页查询

分页在网站使用的十分之多
之前：原始的limit进行分页，或者用一些第三方插件如pageHelper分页
MP其实也内置了分页插件！使用非常方便：

1）配置拦截器组件

@Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }

2)测试分页查询

  //测试分页查询
    @Test
    public void testPage(){
        Page<User> page = new Page<>(1, 5);//当前页，页面大小。第一页显示五条
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());//打印出总共多少行数据

    }

6)删除操作

根据id删除，基本删除操作

//测试删除
    @Test
    public void testDeleteById(){
        userMapper.deleteById(1556204931867017217L);

    }
    //批量删除
    @Test
    public void testDeleteBatchId(){
        userMapper.deleteBatchIds(Arrays.asList(3,4,5));
    }
    //条件删除
    @Test
    public void testDeleteMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","狂神说java");
        userMapper.deleteByMap(map);
    }

逻辑删除

物理删除：从数据库中直接移除
逻辑删除：在数据库中没有被移除，而是通过一个变量来让他失效！ deleted==>deleted=1

例如：管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！

测试：

1）在数据库表中增加deleted字段，长度1，默认值为0

2）实体类中添加属性

    @TableLogic  //逻辑删除
    private int deleted;

3)注册逻辑删除组件

 //逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector(){
        return new LogicSqlInjector();
    }

//注意，高版本的话不需要注册这一步，具体情况参照官网

4)配置逻辑删除

# 配置逻辑删除  已删除1  未删除0
mybatis-plus.global-config.db-config.logic-delete-value=1   
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5)测试

   //测试删除
    @Test
    public void testDeleteById(){
        userMapper.deleteById(4L);

    }

虽然是删除操作但是sql语句执行的是更新 ：UPDATE user SET deleted=1 WHERE id=? AND deleted=0

并且数据也并没有消失，仍然储存在数据库中，只是deleted=1

//再对这个删除的数据进行查询  
public void testSelectById(){
        User user = userMapper.selectById(4L);
        System.out.println(user);
    }

**sql查询语句会自动带上 AND deleted=0 ** ==> Preparing: SELECT id,name,age,email,version,deleted,create_time,update_time FROM user WHERE id=? AND deleted=0

所以查出来为null！！查询时会自动过滤掉deleted=1即被逻辑删除的数据！！

五、性能分析插件

我们在平时的开发中，会遇到一些慢sql，需要把它们测出来！druid

MP也提供了性能分析插件！如果超过这个时间就停止运行

注册插件

  //sql执行效率插件
    @Bean
    @Profile({"dev","test"})  //设置 dev test 环境开启，保证我们的效率
    public PerformanceInterceptor performanceInterceptor(){
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100); //ms，设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true);//sql语句格式化
        return performanceInterceptor;
    }

performanceInterceptor.setMaxTime(100); :设置sql执行运行的最大时间，如果sql执行时间超过，就会执行失败

performanceInterceptor.setFormat(true); ：将sql语句格式化

将环境切换为测试环境或者开发环境才能生效

# 激活为开发环境
spring.profiles.active=dev

测试sql操作

// The SQL execution time is too large, please optimize !  超过规定时间就会抛出异常

使用性能分析插件，可以帮助我们提高效率！找出效率低的sql执行！

六、条件查询器Wrapper

十分重要，我们写一些复杂的sql就可以使用它来替代！

测试一些复杂查询

  @Test
    void contextLoads() {
        //查询name不为空的用户，并且邮箱不为空，并且年龄大于等于12的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNotNull("name")
                .isNotNull("email")
                .ge("age",12);  //大于等于12
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

  //查询名字等于xqh的用户
    @Test
    void test2(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","xqh"); //eq：相等
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

 //查询between。。and  查询年龄在20~30岁之间的用户
    @Test
    void test3(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30);//between:多少到多少之间

        Integer integer = userMapper.selectCount(wrapper);//查询结果数
        System.out.println(integer); //2
    }

 //模糊查询
    @Test
    void test4(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .notLike("name","e")  //不包含e
                //左查询%t   右查询t%
                .likeRight("name","x");

        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

记住查看输出的sql进行分析

  @Test
    void test5(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //id在子查询中查出来
        wrapper.inSql("id","select id from user where id<3");
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

  @Test
    void test6(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //通过age进行降序排序
        wrapper.orderByDesc("age");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);

    }

七、代码自动生成器

dao、pojo、service、controller自己编写完成！

官网学习：https://baomidou.com/pages/d357af/#%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B

package com.qian;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.sql.Array;
import java.util.ArrayList;

//代码自动生成器
public class Code {
    public static void main(String[] args) {
        //需要构建一个 代码自动生成器对象
        AutoGenerator mpg = new AutoGenerator();
        //配置策略:
        //1、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath+"/src/main/java");
        gc.setAuthor("xqh");
        gc.setOpen(false);//是否打开windows文件夹
        gc.setFileOverride(false);//是否覆盖
        gc.setServiceName("%sService");//去掉Service的i前缀
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);
        //2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        //3、包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog");
        pc.setParent("com.qian");
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        //4、策略配置
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//设置要映射的表
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
        strategy.setLogicDeleteFieldName("deleted");
        //自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);
        //乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);
        
        //执行
        mpg.execute();//执行
    }
}