MybatisPlus

地址：

Mybatis Plus： https://mp.baomidou.com/

为了简化开发而生！！！

Plus是什么？

愿景

我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

Plus能帮助我们干什么？

其基本特性如下：

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
• 强大的 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

框架结构

我们使用第三方组件的步骤

1、导入对应的依赖
2、研究依赖如何配置
3、代码如何编写

4、添加扩展

快速开始

1、建表

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

2、导入依赖

  <!-- 数据库驱动 -->
        <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.0.5</version>
        </dependency>

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

会存在版本的差异！

3、配置数据源

# 基本的连接信息
spring.datasource.username=root
spring.datasource.password=cui0411..
spring.datasource.url=jdbc:mysql://localhost:3306/plus?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 显示sql的配置
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4、扫描注解

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹


@MapperScan("com.mapper")
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

5、实体类

@Data
@Accessors(chain = true)
public class User {
    // 主键的生成策略
    @TableId(type = IdType.AUTO)
    private Long id;
    // 逻辑删除
    @TableLogic
    private Integer deleted;
    // 乐观锁
    @Version
    private Integer version;
    private String name;
    private Integer age;
    private String email;
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

6、编写接口

Plus 中的CRUD 接口：

https://mp.baomidou.com/guide/crud-interface.html

Mapper CRUD 接口
说明:

通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为 条件构造器


Service CRUD 接口
说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为 条件构造器

/**
 * @author cyt
 * @create 2020-03-22 15:20
 */
@Repository
public interface PlusUserMapper extends BaseMapper<User> {
    
}

7、开始测试CRUD

    // 注入基础的mapper
    @Autowired
    private PlusUserMapper userMapper;


    @Test
    void contextLoads() {
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }

思路？

1、sql是谁写的？

Plus帮助我们编写的SQL

2、方法是那里来的？

继承BaseMapper后， 就自然拥有的BaseMapper的所有方法。

配置日志、显示SQL

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

8、自动生成ID（注解与反射）

自动填充

创建时间、更新时间需要自动的更新

1、从数据库层面设置

设置默认值， 和更新。

2、从代码上设置

需要被自定填充的字段设置注解，配置填充方式， 删除上一步的数据库设置。

    @TableField(fill = FieldFill.INSERT)

    private Date createTime;

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

配置填充方式

package com.domain;

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;

/**
 * @author cyt
 * @create 2020-03-22 16:02
 */
@Slf4j
@Component
public class FieldTime implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill.....");

        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {

        log.info("start insert fill.....");

        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

重新运作插入测试

乐观锁

乐观锁：十分乐观， 它认为不会出现问题， 无论干什么都不去上锁！ 如果出现了问题， 再次更新测试。

悲观锁：十分悲观， 它认为永远都会出现问题， 干什么都会去上锁， 上锁后， 在去操作！

取出纪录时， 得到当前的version

更新时， 带上这个version

执行跟新时候， set version = newVersion where version = oldVersion

如果version 不对， 就更新失败。

乐观锁： 1、先查询， 获得版本号 version = 1

-- A
update user set name = " ",  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的乐观锁插件

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

    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

}

  // map 条件查询
    @Test
    public void testSelect() {
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "lock");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

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

分页查询

使用MP中集成的插件

配置插件

    // 分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

使用

    @Test
    public void page() {
        //1 当前页
        // 2 页面大小
        Page<User> page = new Page<>(2, 5);
        userMapper.selectPage(page, null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

逻辑删除

物理删除 : 直接从数据库中删除掉

逻辑删除：通过一个标志位来完成逻辑意义上的删除，而非实际删除。

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

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

2、实体类中增加属性

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

3、配置组件

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

4、测试一下删除！

    //测试逻辑删除
    @Test
    public void logistDelete() {
        userMapper.deleteById(1L);
    }

打印的sql语句， 可以看出执行的是更新操作， 而不是删除操作。

观察数据库的字段可以看到， deleted标志位被置为1 ！！！

5、再次查询所有

    @Test
    void contextLoads() {
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }

会增加限制的条件

where deleted = 0

性能分析插件

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

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

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

 /**
     * 性能分析插件
     *
     * @return
     */
    @Profile({"dev"}) // 设置dev环境开启
    @Bean
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }

可以看到抛出了异常的信息。

条件构造器

十分重要：Wrapper

使用条件构造器测试的时候， 一定要注意查看sql分析。

链接 ：

https://mp.baomidou.com/guide/wrapper.html

测试如下：

    // 条件构造器
    @Test
    public void wrapper() {
        //查询名字不为空，年龄大于三的用户
        // 新建构造器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNull("name")
                .ge("age", 3);
        // 使用构造器开始查询
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void wrapper() {
     
        // 新建构造器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
              
                .eq("name", "cyt")
        // 使用构造器开始查询
        List<User> users = userMapper.selectList(wrapper);
        // 查询单个
        // User user = userMapper.selectOne(wrapper);
        users.forEach(System.out::println);
    }

    // 条件构造器
    @Test
    public void wrapper2() {
        // 新建构造器

        // 年龄 20 - 30
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
               .between("age", 20, 30);
        // 使用构造器开始查询,
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

    // 条件构造器
    @Test
    public void wrapper3() {
        // 新建构造器
        //  模糊查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .like("name", "c");
        // 使用构造器开始查询,
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    
    }

    // 条件构造器
    @Test
    public void wrapper4() {
        // 新建构造器
      // sql 来查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.inSql("id", "select id from user where id<3");
        // 使用构造器开始查询,
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

    // 条件构造器
    @Test
    public void wrapper5() {
        // 新建构造器
        // 排序
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("id");
        // 使用构造器开始查询,
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }