Mybatis - Plus

​ 简介

MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。

特性

  • 无侵入:只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑
  • 损耗小:启动即会自动注入基本 CURD,性能基本无损耗,直接面向对象操作
  • 强大的 CRUD 操作:内置通用 Mapper、通用 Service,仅仅通过少量配置即可实现单表大部分 CRUD 操作,更有强大的条件构造器,满足各类使用需求,简单的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. 创建数据库 mybatis_plus
  2. 创建表 user
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(乐观锁) 、deleted(逻辑删除)、gmt_create、gmt_modified
  1. 编写项目,初始化项目!使用SpringBoot初始化!
  2. 导入依赖
<!--        数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
<!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
<!--        mybatis_plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
  1. 连接数据库、这一步跟mybatis一致!
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3307/mybatis?serverTimezone=GMT%2B8&characterEncoding=utf8&useUnicode=true&useSSL=false
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  1. 传统方式pojo-dao( 连接mybatis,配置mapper.xml文件 )-service-controller
  2. 使用Mybatis-plus之后
  • ​ pojo

    package com.xuhu.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author XuHu
     * @version 1.0
     * @date 2020/10/12 14:12
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
    
        private Long id;
        private String name;
        private Integer age;
        private String email;
    }
  • mapper接口

    package com.xuhu.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.xuhu.pojo.User;
    import org.springframework.stereotype.Repository;
    
    /**
     * @author XuHu
     * @version 1.0
     * @date 2020/10/12 14:14
     */
    //在对应的mapper上面实现基本的接口
    @Repository //代表持久层
    public interface UserMapper extends BaseMapper<User> {
    //所有的CRUD操作编写完成,不需要以前的配置一堆文件
    }
  • 注意点:我们需要在主启动类上扫描我们所有mapper包下的所有接口 @MapperScan("com.xuhu.mapper")
  • 测试类测试

    package com.xuhu;
    
    import com.xuhu.mapper.UserMapper;
    import com.xuhu.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 {
    
        //继承了BaseMapper 所有的方法都来自父类,我们也可以自己编写自己的扩展方法
        @Autowired
        private UserMapper userMapper;
    
        @Test
        void contextLoads() {
    
            //参数 是一个 wrapper 条件构造器,这里我们先不用 null
            //查询全部用户
            List<User> users = userMapper.selectList(null);
            users.forEach(System.out::println);
        }
    }
  • 结果

    User(id=1, name=Jone, age=18, email=test1@baomidou.com)
    User(id=2, name=Jack, age=20, email=test2@baomidou.com)
    User(id=3, name=Tom, age=28, email=test3@baomidou.com)
    User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
    User(id=5, name=Billie, age=24, email=test5@baomidou.com)
  • 使用

配置日志


我们所有的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("白千");
        user.setAge(22);
        user.setEmail("1138852559@qq.com");

        int insert = userMapper.insert(user);
        System.out.println(insert);
        System.out.println(user);
    }

结果

JDBC Connection [HikariProxyConnection@1694804085 wrapping com.mysql.cj.jdbc.ConnectionImpl@35e26d05] will not be managed by Spring
==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? ) 
==> Parameters: 1315542711189471234(Long), 白千(String), 22(Integer), 1138852559@qq.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@50f097b5]
1
User(id=1315542711189471234, name=白千, age=22, email=1138852559@qq.com)

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

主键的生成策略

@TableId(type = IdType.ID_WORKER)    默认 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。可以保证几乎全球唯一。

主键自增

我们需要配置主键自增:

  1. 实体类字段上 @TableId(type=IdType.AUTO)
  2. 数据库字段一定要是自增! 如果数据库不是 则会报错

3.再次测试插入即可

其余源码解释

public enum IdType {
AUTO(0),       //数据库id自增
NONE(1),       //未设置主键
INPUT(2),      //手动输入
ID_WORKER(3),  //默认的全局唯一id
UUID(4),       //全局唯一id uuid
ID_WORKER_STR(5); //ID_WORKER 字符串表示法

更新操作


@Test
    public void testUpdate(){
        User user = new User();
        //通过条件自动拼接动态sql
        user.setId(6L);
        user.setName("小白千");
        user.setAge(21);
    //注意:updateById 但是参数是一个对象。
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

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

自动填充


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

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

方式一:数据库级别(工作中不允许使用)

  1. 在表中新增字表 create_time,update_time

数据库修改.png

  1. 再次测试插入方法,我们需要先在实体类同步。

    private Date createTime;
        private Date updateTime;
  2. 再次查看结果即可。

方式二:代码级别

  1. 删除数据库的默认值,更新操作

代码实现.png

  1. 实体类的字段属性上需要添加注解

    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
  2. 编写处理器来处理注解即可!
  3. 测试更新观察时间即可!

乐观锁


在面试过程中 会被经常问到乐观锁,悲观锁!这个其实非常简单!

乐观锁:顾名思义 十分乐观,它总是认为不会出现问题,无论干什么都会不去上锁!如果出现了问题,再次更新值测试 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

测试MyBatis-Plus乐观锁插件

  1. 给数据库添加version字段 默认值为1.
  2. 给实体类加对应的字段

    @Version   //乐观锁注解
        private Integer version;
  3. 注册组件

    @MapperScan("com.xuhu.mapper")  //扫描包
    @EnableTransactionManagement  //管理实务
    @Configuration //配置类
    public class MyBatisPlusConfig {
        //注册乐观锁插件
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() {
            return new OptimisticLockerInterceptor();
        }
    }
  4. 测试一下

    //测试乐观锁——成功
        @Test
        public void testOptimisticLocker(){
            //1.查询用户信息
            User user = userMapper.selectById(1315542711189471238L);
            //2.修改用户信息
            user.setName("白千");
            //3.执行更新操作
            userMapper.updateById(user);
        }
        //测试乐观锁——失败
        @Test
        public void testOptimisticLockerFail(){
            // 线程 1
            //------------------------------------------
            //1.查询用户信息
            User user = userMapper.selectById(1315542711189471238L);
            //2.修改用户信息
            user.setName("小白千");
            //---------------------------------
            //线程2  模拟插队操作
            //--------------------------------------------
            //1.查询用户信息
            User user2 = userMapper.selectById(1315542711189471238L);
            //2.修改用户信息
            user2.setName("大白千");
            //3.执行更新操作
            userMapper.updateById(user2);
            //---------------------------
            //3.线程1执行更新操作
            userMapper.updateById(user);  //如果没有乐观锁 就会覆盖插队线程的值
        }

查询操作


//测试查询
 @Test
 public void testSelectId(){
     List<User> user = userMapper.selectBatchIds(Arrays.asList(1L,2L,3L));
//        User user1 = userMapper.selectById(1L);
     user.forEach(System.out::println);
 }
 //条件查询之一 map操作
 @Test
 public void testSelectByBatchIds(){
     HashMap<String, Object> map = new HashMap<>();
     //自定义查询
     map.put("name","白千");
     .....
     List<User> users = userMapper.selectByMap(map);
     users.forEach(System.out::println);
 }

分页查询


分页在网站使用的十分之多!

  1. 原始的limit进行分页
  2. pageHelper第三方插件
  3. MP其实也内置分页

如何使用

  1. 配置拦截器组件

    //分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
     return new PaginationInterceptor();
    }
  2. 直接使用page对象即可

    //测试分页查询
    @Test
    public void testPage(){
     // 参数一:当前页
     // 参数二:页面大小
     // 使用了分页插件之后,所有的分页操作变的简单了
     Page<User> page = new Page<>(1,3);
     userMapper.selectPage(page,null);
     page.getRecords().forEach(System.out::println);
     System.out.println(page.getTotal());//查询总数
    }

删除操作


//测试删除
    @Test
    public void testDeleteById(){
        int i = userMapper.deleteById(1315542711189471238L);
        System.out.println(i);
    }
    //批量id删除
    @Test
    public void testDelectBatchIds(){
        userMapper.deleteBatchIds(Arrays.asList(1315542711189471237L,1315542711189471239L));
    }
   //批量条件删除
    @Test
    public void testDelectMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","白千");
        userMapper.deleteByMap(map);
    }

逻辑删除


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

逻辑删除:在数据库中没有被移除,而是通过变量来让他失效。deleted = 0 || deleted = 1

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

测试一下:

  1. 在数据库中添加deleted字段
  2. 实体类中添加属性。
  3. 配置

    //逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector(){
     return new LogicSqlInjector();
    }
# 配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0
  1. 测试一下删除!(查询的时候会自动过滤所删除的字段)

注意:3.3.0版本以后 将不再需要配置 直接yml文件全局配置 实体类无需注解

3.3.0使用方法:

步骤1: 配置 com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig

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

步骤2: 实体类字段上加上@TableLogic注解

@TableLogic
private Integer deleted;

以上所有的CRUD操作及其扩展操作,必须掌握精通

性能分析插件

我们在平时的开发中,我们会遇到一些慢sql。

作用:性能分析拦截器,用于输出每天sql语句和运行时间。

MP也提供了性能分析插件,如果超过设定时间 就停止运行。

  1. 导入配置

    /**
     * SQL执行效率插件
     */
    @Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() {
     PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
     performanceInterceptor.setMaxTime(10); //设置sql执行的最大时间  如果超过了不执行
     performanceInterceptor.setFormat(true); //格式化sql语句
     return performanceInterceptor;
    }
# 设置运行环境
spring.profiles.active=dev
  1. 运行一下

    如果超过时间报错
    错误:The SQL execution time is too large, please optimize !

新版本已删除

条件构造器

十分重要!wrapper

我们在写一些复杂的sql就可以使用它来替代

  1. 测试一,记住查看输出的sql进行分析

    @Test
    void contextLoads() {
     //查询name不为空,邮箱不为空,年龄大于等于22
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper
             .isNotNull("name")
             .isNotNull("email")
             .ge("age",22);
     //和刚刚学习的map对比一下
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
    }
  2. 测试二,记住查看输出的sql进行分析

    @Test
    void test2(){
     //查询名字
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.eq("name","xx白千");
     User user = userMapper.selectOne(wrapper);//查询一个结果   出现多个结果使用List 或者 Map
     System.out.println(user);
    }
  3. 测试三,记住查看输出的sql进行分析

    @Test
    void test3(){
     //查询年龄在22-30之间的人员
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.between("age",22,30);  //区间
     Integer integer = userMapper.selectCount(wrapper); //查询结果数量
     System.out.println(integer);
    }
  4. 测试四,记住查看输出的sql进行分析

    @Test
    void test4(){
     //模糊查询 名字中间没有a的
     QueryWrapper<User> wrapper = new QueryWrapper<>();
    //        wrapper.notLike("name","a");  //name字段 不包含a的
     wrapper.like("name","a");  //name 字段 包含a的
     //左和右  代表 %a||a%
    //        wrapper.likeLeft()
    //                .likeRight()
     List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
     maps.forEach(System.out::println);
    }
  5. 测试五,记住查看输出的sql进行分析

    @Test
    void test5(){
     //模糊查询 id在子查询中查出来
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.inSql("id","select id from user where id<3");
     List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
     maps.forEach(System.out::println);
    }
  6. 测试六,记住查看输出的sql进行分析

    @Test
    void test6(){
     //查询排序 通过id进行排序
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.orderByAsc("id");
     List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
     maps.forEach(System.out::println);
    }

剩下官网查询

代码生成器

dao、pojo、service、controller都自动生成

AutoGenerator 是 MyBatis-Plus 的代码生成器,通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码,极大的提升了开发效率。

测试:

//代码自动生成器
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("xuhu");  //设置作者信息
        gc.setOpen(false);      //是否打开文件资源管理器
        gc.setFileOverride(false); //是否覆盖
        gc.setServiceName("%sService"); //去 Service 的I前缀
        gc.setIdType(IdType.ID_WORKER); //id唯一类型
        gc.setDateType(DateType.ONLY_DATE); //时间日期的类型
        gc.setSwagger2(true);  //是否生成Swagger2
        mpg.setGlobalConfig(gc);//放进生成器里
            //设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3307/mybatis?serverTimezone=GMT%2B8&characterEncoding=utf8&useUnicode=true&useSSL=false");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

                //包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog");
        pc.setParent("com.xuhu");
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

                //策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("userlogs");  //映射的表名
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);//自动生成lombok
        strategy.setLogicDeleteFieldName("deleted");//逻辑删除
        //自动填充配置
        TableFill createTime = new TableFill("create_time", FieldFill.INSERT);//表名 请用国际化标准 gmt_create
        TableFill updateTime = new TableFill("update_time", FieldFill.INSERT_UPDATE);//表名 请用国际化标准 gmt_modified
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(createTime);
        tableFills.add(updateTime);
        strategy.setTableFillList(tableFills);
        //乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);  //localhost:8080/hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute();//执行代码构造器
    }

小结

Last modification:October 13th, 2020 at 01:47 pm