mybatis-plus使用详情教程

 

快速入门：

步骤：

1.创建数据库 mybatis_plus

2.创建数据库表，插入数据

create database mybatis_plus;

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)
);

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');

 3、编写项目，初始化项目！使用SpringBoot初始化！

 4、导入依赖

<!--数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!--mybatis-plus-->
<!--mybatis-plus 是自己开发，并非官方的！-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
</dependency>

说明:我们使用mybatis-plus可以节省我们大量的代码，尽量不要同时导入mybatis和mybatis-plus！版本的差异！

5、连接数据库！这一步和mybatis相同！

#mysql5 驱动不同
#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 驱动不同、需要添加时区的配置  serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

 6、pojo-dao(连接mybatis，配置mapper.xml文件)-service-controller（传统方式）

 6、使用了mybatis-plus之后

• pojo

/**
 * @Author panghl
 * @Date 2020/10/15 22:18
 * @Description TODO
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Long id;
    private String name;
    private Integer age;
    private String email;

}

• mapper接口

/**
 * @Author panghl
 * @Date 2020/10/15 22:19
 * @Description 在对应的Mapper上面实现基本的接口BaseMapper
 **/
@Repository //代表持久层
public interface UserMapper extends BaseMapper<User> {
    //所有的CRUD操作都已经编写完成了
    //你不需要像以前的配置一大堆文件了！
}

注意点，我们需要再主启动类上去扫描我们的mapper包下的所有接口 @MapperScan("com.kuang.mapper")

• 使用:测试类的测试

@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了BaseMapper，所有的方法都来自父类，我们也可以编写自己的扩展方法
    @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

配置完毕日志之后，后面的学习就需要注意这个自动生成的SQL，你们就会喜欢上Mybatis-plus！

 

CRUD扩展

   插入操作

•   Insert：

    //测试插入
    @Test
    public void testInsert(){
        User user = new User();
        user.setName("狂神说Java");
        user.setAge(3);
        user.setEmail("phhl@qq.com");
        int result = userMapper.insert(user);//帮我们自动生成id
        System.out.println(result);//受影响的行数
        System.out.println(user);//发现，id会自动回填
    }

 

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

 

主键生成策略

默认IdType.ID_WORKER全局唯一id

分布式系统唯一id生成:https://www.cnblogs.com/haoxinyue/p/5208136.html

雪花算法:

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter/snowflake.可以保证几乎全球唯一！

1. id全局唯一
2. 高性能，低延迟
3. 独立的应用
4. 按时间有序
5. 需要独立的开发和部署

 

主键自增

我们需要配置主键自增:

1、实体类字段上 

@TableId(type = IdType.AUTO)

2、数据库字段一定要是自增！

3、再次测试插入即可！

//其余的源码解释:

public enum IdType {
    AUTO(0), //数据库id自增
    NONE(1), //未设置主键
    INPUT(2), //手动输入  一旦手动输入就需要自己写id
    ASSIGN_ID(3), 
    ASSIGN_UUID(4), 
    /** @deprecated */
    @Deprecated
    ID_WORKER(3), //默认的全局唯一id  mp自带策略:生成19位值，数字类型使用这种策略，比如long
    /** @deprecated */
    @Deprecated
    ID_WORKER_STR(3), // 全局唯一id uuid  默认的全局唯一id  mp自带策略:生成19位值，字符串类型使用这种策略
    /** @deprecated */
    @Deprecated
    UUID(4);  //随机唯一值
}

 

更新操作

   update:

    //测试更新
    @Test
    public void testUpdate(){
        User user = new User();
        // 通过条件自动拼接动态sql
        user.setId(1L);
        user.setName("Update");
        user.setAge(88);
        //注意:updateById 但是参数是一个对象！
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

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

自动填充

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

阿里巴巴开发手册:所有的数据库表:gmt_create、gmt_modified几乎所有的表都要配置上！而且需要自动化！

1. 方式一：数据库级别（工作中不推荐使用）

1、在表中新增字段 create_time，update_time

2、再次测试插入方法，我们需要先把实体类 同步！

    private Date createTime;
    private Date updateTime;

 3、再次更新查看结果即可

1. 方式二：代码级别

1、删除数据库的默认值、更新操作！

2、实体类字段属性上需要添加注解

    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

3、编写处理器来处理这个注解即可！

/**
 * @Author panghl
 * @Date 2020/10/15 23:25
 * @Description 自动填充功能
 **/
@Slf4j
@Component  //一定不要忘记把处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill...");
        //    default MetaObjectHandler 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、测试插入、更新、观察时间即可！

 

乐观锁

在面试过程中，我们经常被问到乐观锁，悲观锁！这个其实非常简单！

乐观锁:顾名思义十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现问题，再次更新值测试。通过version、new version来实现。

悲观锁:顾名思义十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！

我们主要讲解 乐观锁机制！

主要适用场景

意图：

当要更新一条记录的时候，希望这条记录没有被别人更新

乐观锁实现方式：

• 取出记录时，获取当前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

-- B 线程抢先完成，这个时候 version = 2 ，会导致A修改失败！
update user set name = "kuangshen",version = version + 1
where id = 2 and version = 1

 测试一下MP的乐观锁插件：

  1、给数据库中增加version字段，默认值设置为1

2、我们实体类增加version属性 

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

3、注册乐观锁插件

/**
 * @Author panghl
 * @Date 2020/10/16 22:18
 * @Description TODO
 **/
@EnableTransactionManagement
//扫描我们的mapper文件夹
@MapperScan("com.kuang.mapper")
@Configuration  //配置类
public class MybatisPlusConfig {

    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

}

4、测试乐观锁 

    //测试乐观锁成功！
    @Test
    public void testOptimisticLocker(){
        //1.查询用户信息
        User user= userMapper.selectById(1L);
        //2.修改用户信息
        user.setName("kuangshen");
        user.setEmail("phl2566@qq.com");
        //3.执行更新操作
        userMapper.updateById(user);
    }

    //测试乐观锁失败!多线程下
    @Test
    public void testOptimisticLocker2(){
        //线程1
        User user= userMapper.selectById(1L);
        user.setName("kuangshen");
        user.setEmail("phl2566@qq.com");

        //模拟另外一个线程执行了插队操作
        User user2= userMapper.selectById(1L);
        user2.setName("kuangshen");
        user2.setEmail("phl2566@qq.com");
        userMapper.updateById(user2);

        //自旋锁来多次尝试操作
        userMapper.updateById(user);//如果没有乐观锁就会覆盖插队线程的值
    }

 

 
查询操作

    //测试查询
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

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

    //按条件查询之一使用map操作
    @Test
    public void testSelectByMap(){
        HashMap<String,Object> map = new HashMap<>();
        //自定义要查询
        map.put("name","狂神说Java");
        map.put("age",3);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

 分页查询

分页在网站使用的十分之多！(必须掌握)

1、原是的limit进行分页

2、pageHelper第三方插件

3、其实也内置了分页插件！

如何使用：

1、配置拦截器组件即可

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }

2、直接使用Page对象即可！ 

    //测试分页查询
    @Test
    public void testPage(){
        //参数1：当前页
        //参数2: 页面大小
        //使用了分页插件之后，所有的分页操作也变得简单了！
        Page<User> page = new Page<>(1,3);
        userMapper.selectPage(page, null);
//        page.getRecords() 获取它的所有记录
        page.getRecords().forEach(System.out::println);
        System.out.println("总数:"+page.getTotal());
        System.out.println("当前页"+page.getCurrent());
        System.out.println("大小"+page.getSize());
        System.out.println("是否有上一页"+page.hasPrevious());
        System.out.println("是否有下一页"+page.hasNext());
    }

 

删除操作

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

    //测试id批量删除
    @Test
    public void testDeleteByIds(){
        userMapper.deleteBatchIds(Arrays.asList(1316751832526925826L,1316751832526925827L));
    }

    //通过map删除
    @Test
    public void testDeleteByMap(){
        HashMap<String,Object> map = new HashMap<>();
        map.put("name","狂神说Java");
        userMapper.deleteByMap(map);
    }

我们在工作中会遇到一些问题：逻辑删除！ 

逻辑删除

物理删除：从数据库中直接删除

逻辑删除：在数据库中没有背移除，而是通过一个变量来让他失效！delete=0 =>  delete=1

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

测试一下：

1、在数据库中增加一个deleted字段

2、 实体类中增加属性

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

3、配置 

高版本只需要配置 配置文件里的配置信息！

#配置逻辑删除
# 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
mybatis-plus.global-config.db-config.logic-delete-field=deleted
#逻辑已删除值(默认为1)
mybatis-plus.global-config.db-config.logic-delete-value=1
#逻辑未删除值(默认为0)
mybatis-plus.global-config.db-config.logic-not-delete-value=0

低版本需要在MybatisPlusConfig类中配置：

    /*低版本配置逻辑删除*/
    @Bean
    public ISqlInjector sqlInjector(){
        return new LogicSqlInjector();
    }

4.测试一下

 

以上的所有CRUD操作及其扩展操作，我们都必须精通掌握！会大大提高你的工作和写项目的效率！

 

性能分析插件（执行SQL分析打印）

由于使用的3.2.0以上版本，在MybatisPlus文档中可使用 执行SQL分析打印 功能

该功能依赖p6spy组件，完美的输出打印SQL及执行时长！

我们在平时的开发中，会遇到一些慢sql。测试！druid...来发现！

作用:性能分析拦截器，用于输出每条SQL语句及其执行时间。

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

这里提供低版本演示：

 

1.添加依赖

<dependency>
     <groupId>p6spy</groupId>
     <artifactId>p6spy</artifactId>
     <version>3.8.7</version>
</dependency>

2、导入组件

   /**
   * SQL 执行性能分析插件
   * 开发环境使用，线上不推荐。 maxTime指的是sql最大执行时长
   * @return
   */
@Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true);//是否格式化代码
        return new PerformanceInterceptor();
    }

 记住，要在SpringBoot配置环境为dev或者test环境！

3、在配置文件中添加

#环境设置:dev \test \prod
spring.profiles.active=dev

4、测试使用！

 

 

条件构造器

可参考mybatis-plus官方文档(https://baomidou.com/guide/wrapper.html#abstractwrapper)

条件参数说明

查询方式	说明
setSqlSelect	设置 SELECT 查询字段
where	WHERE 语句，拼接 + WHERE 条件
and	AND 语句，拼接 + AND 字段=值
andNew	AND 语句，拼接 + AND (字段=值)
or	OR 语句，拼接 + OR 字段=值
orNew	OR 语句，拼接 + OR (字段=值)
eq	等于=
allEq	基于 map 内容等于=
ne	不等于<>
gt	大于>
ge	大于等于>=
lt	小于<
le	小于等于<=
like	模糊查询 LIKE
notLike	模糊查询 NOT LIKE
in	IN 查询
notIn	NOT IN 查询
isNull	NULL 值查询
isNotNull	IS NOT NULL
groupBy	分组 GROUP BY
having	HAVING 关键词
orderBy	排序 ORDER BY
orderAsc	ASC 排序 ORDER BY
orderDesc	DESC 排序 ORDER BY
exists	EXISTS 条件语句
notExists	NOT EXISTS 条件语句
between	BETWEEN 条件语句
notBetween	NOT BETWEEN 条件语句
addFilter	自由拼接 SQL
last	拼接在最后，例如：last("LIMIT 1")

示例代码

    //记住查看输出的SQL进行分析
    @Test
    void test1(){
        //查询name不为空的用户,并且邮箱不为空的用户，年龄大于等于12
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.isNotNull("name");
        userQueryWrapper.isNotNull("email");
        userQueryWrapper.ge("age",12);
        userMapper.selectList(userQueryWrapper).forEach(System.out::println);
    }

    @Test
    void test2(){
        //查询名字  狂神说
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name","狂神说");
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

    @Test
    void test3(){
        //查询年龄在20-30岁之间的用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.between("age",20,30);
        Integer count = userMapper.selectCount(queryWrapper);//查询结果数
        System.out.println(count);
    }

    //模糊查询
    @Test
    void test4(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //左和右  e%
        queryWrapper
                .notLike("name","e")
                .likeRight("email","t");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

    //模糊查询
    @Test
    void test5(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //id 在子查询中查出来
        /*SELECT id,name,age,email,version,deleted,create_time,update_time
        FROM user
        WHERE deleted=0
        AND (id IN
                (select id
                        from user
                        where id < 3))*/
        queryWrapper.inSql("id","select id from user where id < 3");

        List<Object> objects = userMapper.selectObjs(queryWrapper);
        objects.forEach(System.out::println);
    }

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

    }

其余的测试，可以下去多多练习！

 

代码自动生成器

dao、pojo、service、controller都给我自己去编写完成！ AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、 Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

1、导入mvn坐标

        <!--mybatis-plus-->
        <!--mybatis-plus 是自己开发，并非官方的！-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--MP代码自动生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>

        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>

2、测试

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.util.ArrayList;
// 代码自动生成器
public class KuangCode {
    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("狂神说");
        gc.setOpen(false);
        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&serverTimezone=GMT%2B8");
        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.kuang");
        pc.setEntity("entity");
        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); // 自动lombok；
        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); //localhost:8080/hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }
}

此时大功已成！