springboot整合mybatis-plus， mybatis-plus的代码生成器

MyBatis-Plus 简介

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
• 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
• 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错 【JDK1.8 的新特性】
• 支持主键自动生成：支持多达 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

mybatis-plus快速入门

mybatis-plus的官网：https://baomidou.com/guide
（1）其对应的数据库 Schema 脚本如下：

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[乐观锁] gmt_createtime gmt_updatetime 这些是阿里的标准。
（2）引入mybatis-plus依赖

 <!--引入mybatis-plus的依赖 不要再引入mybatis的依赖 因为这两者之间可能存在冲突。-->
  <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>Latest Version</version>
    </dependency>

用到的全部依赖
springboot-web启动器，
springboot-web-test启动器，
mysql依赖
druid启动器
mybatis-plus-generator代码生成器
velocity 模板引擎依赖
mybatis-plus启动器
lombok依赖
swagger启动器

  <!--springboot-web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>
        <!--springboot-test启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--        mybatis-plus-generator代码生成器：只是工具  不能代表mp-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!-- 代码生成器模板****目前用到的只和mp生成器连用-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>
        <!--mp启动器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--swagger2-->
        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.9.1.RELEASE</version>
        </dependency>
        <!--lombok小辣椒-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

（3） 数据源的配置
spring.datasource.druid.password=root
spring.datasource.druid.username=root
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql:///mybatis-plus?serverTimezone=UTC
（4）创建实体类以及dao 接口 必须继承BaseMapper接口

public interface UserDao extends BaseMapper<User> {
}

(5) 在主启动类上添加dao接口的扫描

@SpringBootApplication
@MapperScan(basePackages = "com.zz.dao")
public class SpringbootMpApplication {

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

（6）测试

@Test
    void contextLoads() {
        //Wrapper:条件封装类。----null
        //查询所有
        List<User> list = userDao.selectList(null);
        System.out.println(list);
    }

添加时自定义ID生成器

自3.3.0开始,默认使用雪花算法+UUID(不含中划线)

用法：需要在实体类的主键字段上添加 @TableId(type = IdType.AUTO)
这里面的type类型有多个
AUTO自动增长，如果使用这种方式，必须该列为自增 普通就通用不用于分布式
@TableId(type = IdType.AUTO)
ASSIGN_ID雪花算法，适合long和String类型 适用于分布式 数据库字段可以不设置为自增
None和Input要求客户必须输入Id
（1）实体类：

//    AUTO自动增长，如果使用这种方式，必须该列为自增  普通就通用不用于分布式
//    @TableId(type = IdType.AUTO)
//    ASSIGN_ID适合long和String类型 适用于分布式  数据库字段可以不为自增
//    None和Input要求客户必须输入Id
//    @TableId(type = IdType.ASSIGN_ID)
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;

（2）测试：

//    添加返回主键
    @Test
    public void insert(){
        User user = new User();
        user.setAge(33);
        user.setName("哇哇哇111");
        user.setEmail("2222222.qq.com");
        userMapper.insert(user);
    }

修改

字段的自动填充功能

（1）在需要自动填充的字段上添加注解
@TableField(fill = FieldFill.INSERT)
FieldFill.INSERT表示添加
FieldFill.INSERT_UPDATE表示添加或修改
1.Date 日期类型的参数类型

//    插入时自动填充
    @TableField(fill = FieldFill.INSERT)
    private Date gmtCreated;

//    在插入或修改时自动填充
    @TableField(fill = FieldFill.UPDATE)
    private Date gmtUpdated;

2.LocalDateTime 日期类型的参数类型

//自动填充的字段在添加时候填充
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime gmtCreated;

//    在添加或修改时候自动填充
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime gmtUpdated;

（2）创建一个类并实现MetaObjectHandler接口

1.Date 日期类型的参数类型

@Component
public class MyHandler implements MetaObjectHandler {
//    当执行添加操作室执行此方法
    @Override
    public void insertFill(MetaObject metaObject) {
//        第一个参数固定   第二个参数为列名   第三列为参数的类型   第四个参数表示列的值
        this.strictInsertFill(metaObject, "gmtCreated", Date.class, new Date()); // 起始版本 3.3.0(推荐使用)
    }

//    当执行修改操作时执行此方法
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "gmtUpdated", Date.class, new Date()); // 起始版本 3.3.0(推荐使用)

    }
}

2.LocalDateTime 日期类型的参数类型

@Component
public class MyHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
    // 第一个参数固定   第二个参数为列名   第三列为参数的类型   第四个参数表示列的值
        this.strictInsertFill(metaObject, "gmtCreated", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "gmtUpdated",  LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
    }
}

删除

物理删除 从数据库中直接删除掉数据
逻辑删除 只删除数据 不会对数据库有任何影响。 (增加一个字段 isdeleted) 修改工作。

//    删除逻辑删除增加一个isdeleted修改工作
//    1 未删 0已删
    @Test
    public void delete(){
        int i = userMapper.deleteById(1);
    }

需要在实体类上的逻辑删除列上添加 @TableLogic

//    表示逻辑删除列
    @TableLogic
    private Integer isdeleted;

需要在application.properties或者application.yml中配置如下内容：

# 逻辑未删除值(默认为 0)
mybatis-plus.global-config.db-config.logic-not-delete-value=1
# 逻辑已删除值(默认为 1) 
mybatis-plus.global-config.db-config.logic-delete-value=0

如下是删除的sql

UPDATE user SET isdeleted=0 WHERE id=? AND isdeleted=1

查询

select

（1）首先创建一个QueryWrapper对象，类型为需要查询的实体对象。，
（2）然后调用userMapper.selectList方法，入参就为前面新建好的查询对象封装类。

QueryWrapper

**说明：**继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取

//普通方法
java wrapper.like("name","哈哈");
//lambda表达式链式编程
java wrapper.lambda() .like(User::getName, "哈哈");

  //    查询sql
    @Test
    public void select() {
//        根据id查询用户信息
        User user = userMapper.selectById(4);
        System.out.println(user);
        // 条件构造器    QueryWrapper：相当于sql的where语句后面的条件
        //        根据条件查询多条记录wrapper 子类有QueryWrapper
        QueryWrapper<User> wrapper = new QueryWrapper();
           //查询指定列
        wapper.select("name", "age");
        //like： 模糊查询 name LIKE ?
        //普通方法
   /*     if (StringUtils.isNotEmpty(user.getName())) {

            wrapper.like("name","哈哈");
        }
      if (user.getAge()!=0){

          wrapper.between("age",10,25);
      }*/
      //lambda表达式链式编程
        if (StringUtils.isNotEmpty(user.getName())) {
            wrapper.lambda()
                    .like(User::getName, "哈哈");
        }
        if (user.getAge()!=0){
            wrapper.lambda()
                    .between(User::getAge,11,44);
        }
        List list = userMapper.selectList(wrapper);
        System.out.println(list);
    }

注意：StringUtils这个工具类需要引入工具包

<!--        引入工具包-->
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

UpdateWrapper

//    修改sql 带条件查询
    @Test
    public void updateSelect(){
        User user = new User();
        user.setName("xixix");
        user.setId(6l);
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("name",user.getName())
                .eq("id",user.getId());
        userMapper.update(user,updateWrapper);
    }

分页查询

(1)先创建一个配置类

@Configuration
public class MybatisPlusConfig {
    
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
    
}

（2）测试
分页查询条件：
Page page = new Page(3, 2);

//    分页查询
    @Test
    public void pageHander() {
        Page<User> page = new Page(3, 2);
        page = userMapper.selectPage(page, null);
        System.out.println("当前的页码"+page.getCurrent());
        System.out.println("得到总页码"+page.getPages());
        System.out.println("总条数"+page.getTotal());
        System.out.println("当前页码的记录"+page.getRecords());
    }

mybatis-plus的代码生成器

（1）添加依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.2</version>
</dependency>

（2）添加 模板引擎 依赖，Velocity（默认）：

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>

（3）创建CodeGenerator，并执行就能自动生成代码

package com.zz.springbootgenerator;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {

    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
//        获取工程的根目录
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");//
        gc.setAuthor("张峥");
        gc.setOpen(false);//是否生成代码后打开本地目录
        gc.setSwagger2(true); //是否生存实体属性 Swagger2 注解
        gc.setServiceName("%sService"); //service命名
      //gc.setMapperName("%sDao"); //Dao命名
//
        mpg.setGlobalConfig(gc);//是否设置全局配置

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis-plus?serverTimezone=Asia/Shanghai&useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);


        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("aaa");//模块名
        pc.setParent("com.zz");//设置父包  com.zz.aaa.controller  dao  service entity
//        设置dao
        pc.setMapper("dao");
        mpg.setPackageInfo(pc);


        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };

        // 如果模板引擎是 velocity
        String templatePath = "/templates/mapper.xml.vm";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
//        预计目录   mapper/aaa/UserMapper.xml
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        //关闭系统模板引擎
        templateConfig.setXml(null);
        //放入空的模板引擎替换掉默认的模板引擎
        mpg.setTemplate(templateConfig);
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);


        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);//是否采用驼峰命名
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//列是否要驼峰命名
        strategy.setEntityLombokModel(true);//        是否要lombok
        //        是否要前缀
        strategy.setTablePrefix("acl_");
        //  strategy.setTablePrefix("sys_","bus_");  数据库多个不同的前缀可以写多个
        strategy.setRestControllerStyle(true);//controller是否使用restful风格

        mpg.setStrategy(strategy);
        mpg.execute();
    }

}

乐观锁与悲观锁

1.乐观锁 字面意思: 很乐观，操作数据库时不会加任何的锁。当出现错误时，他才会检查。
只需要再数据库中增加一个新的字段version.
2.悲观锁: 操作数据库都会上锁。

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

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

（1）需要在实体类的version字段上加上@Version注解，数据库version字段默认值为1

//    乐观锁
    @Version
    private int version;

（2）需要添加配置类

//Spring boot方式
@Configuration
public class MybatisPlusConfig {

    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//       乐观锁
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }

}

①修改成功的乐观锁

//    乐观锁
    @Test
    public void version(){
        User user = userMapper.selectById(6l);
        user.setName("wwwwww");
        user.setAge(23);
        userMapper.updateById(user);
    }

②修改失败的乐观锁
模拟两个线程只能有一个修改成功

    @Test
    public void version2(){
        //模拟线程A
        User user = userMapper.selectById(5);
        user.setName("1111zhang");
        user.setAge(12);

//        模拟线程B
        User user1 = userMapper.selectById(5);
        user1.setName("1222222zzz");
        user1.setAge(33);
//执行update操作   线程B被修改，线程A没有被修改
        userMapper.updateById(user1);
		//自旋锁CAS
        userMapper.updateById(user);

    }

运行结果如下：