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

特性

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

  支持数据库

• mysql 、 mariadb 、 oracle 、 db2 、 h2 、 hsql 、 sqlite 、 postgresql 、 sqlserver
  

• 达梦数据库 、 虚谷数据库 、 人大金仓数据库
  

  框架结构

  

• 代码： Gitee | Github

• 文档：https://mybatis.plus/
• MyBatis-Plus 入门 - 视频教程 - 慕课网

• MyBatis-Plus 进阶 - 视频教程 - 慕课网

  快速开始

  我们将通过一个简单的 Demo 来阐述 MyBatis-Plus 的强大功能，在此之前，我们假设您已经：

• 拥有 Java 开发环境以及相应 IDE

• 熟悉 Spring Boot
• 熟悉 Maven

现有一张 User 表，其表结构如下：

其对应的数据库 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)
);

其对应的数据库 Data 脚本如下：

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

Question
如果从零开始用 MyBatis-Plus 来实现该表的增删改查我们需要做什么呢？

初始化工程

创建一个空的 Spring Boot 工程（工程将以 H2 作为默认数据库进行演示）
可以使用 Spring Initializer 快速初始化一个 Spring Boot 工程

添加依赖

引入 Spring Boot Starter 父工程：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
    <relativePath/>
</parent>

引入 spring-boot-starter、spring-boot-starter-test、mybatis-plus-boot-starter、lombok、h2 依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.3.0</version>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

配置

在 application.yml 配置文件中添加 H2 数据库的相关配置：

# DataSource Config
spring:
  datasource:
    driver-class-name: org.h2.Driver
    schema: classpath:db/schema-h2.sql
    data: classpath:db/data-h2.sql
    url: jdbc:h2:mem:test
    username: root
    password: test

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

@SpringBootApplication
@MapperScan("com.baomidou.mybatisplus.samples.quickstart.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(QuickStartApplication.class, args);
    }
}

编码

编写实体类 User.java（此处使用了 Lombok 简化代码）

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

编写Mapper类 UserMapper.java

public interface UserMapper extends BaseMapper<User> {
}

开始使用

添加测试类，进行功能测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SampleTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        Assert.assertEquals(5, userList.size());
        userList.forEach(System.out::println);
    }
}

UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper，所以不填写就是无任何条件
控制台输出：

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)

完整的代码示例请移步：Spring Boot 快速启动示例 | Spring MVC 快速启动示例

小结

通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！
从以上步骤中，我们可以看到集成MyBatis-Plus非常的简单，只需要引入 starter 工程，并配置 mapper 扫描路径即可。
但 MyBatis-Plus 的强大远不止这些功能，想要详细了解 MyBatis-Plus 的强大功能？那就继续往下看吧！

安装

全新的 MyBatis-Plus 3.0 版本基于 JDK8，提供了 lambda 形式的调用，所以安装集成 MP3.0 要求如下：

• JDK 8+
• Maven or Gradle

JDK7 以及下的请参考 MP2.0 版本，地址：2.0 文档

Release

Spring Boot

Maven：

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.0</version>
</dependency>

Gradle：

compile group: 'com.baomidou', name: 'mybatis-plus-boot-starter', version: '3.3.0'

Spring MVC

Maven:

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

Gradle：

compile group: 'com.baomidou', name: 'mybatis-plus', version: '3.3.0'

引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差异导致的问题。

Snapshot

快照 SNAPSHOT 版本需要添加仓库，且版本号为快照版本 点击查看最新快照版本号。
Maven：

<repository>
    <id>snapshots</id>
    <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
</repository>

Gradle：

repositories {
    maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
}

配置

MyBatis-Plus 的配置异常的简单，我们仅需要一些简单的配置即可使用 MyBatis-Plus 的强大功能！
在讲解配置之前，请确保您已经安装了 MyBatis-Plus，如果您尚未安装，请查看 安装 一章。

• Spring Boot 工程：

  • 配置 MapperScan 注解
    

    @SpringBootApplication
    @MapperScan("com.baomidou.mybatisplus.samples.quickstart.mapper")
    public class Application {
    public static void main(String[] args) {
       SpringApplication.run(QuickStartApplication.class, args);
    }
    }

• Spring MVC 工程：

  • 配置 MapperScan
    

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.baomidou.mybatisplus.samples.quickstart.mapper"/>
    </bean>

  • 调整 SqlSessionFactory 为 MyBatis-Plus 的 SqlSessionFactory
    

    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    </bean>

    通常来说，一般的简单工程，通过以上配置即可正常使用 MyBatis-Plus，具体可参考以下项目：Spring Boot 快速启动示例、Spring MVC 快速启动示例。
    同时 MyBatis-Plus 提供了大量的个性化配置来满足不同复杂度的工程，大家可根据自己的项目按需取用

注解

介绍 MybatisPlus 注解包相关类详解(更多详细描述可点击查看源码注释)

注解类包：
👉 mybatis-plus-annotation

@TableName

• 描述：表名注解 | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | —- | | value | String | 否 | “” | 表名 | | schema | String | 否 | “” | schema | | keepGlobalPrefix | boolean | 否 | false | 是否保持使用全局的 tablePrefix 的值(如果设置了全局 tablePrefix 且自行设置了 value 的值) | | resultMap | String | 否 | “” | xml 中 resultMap 的 id | | autoResultMap | boolean | 否 | false | 是否自动构建 resultMap 并使用(如果设置 resultMap 则不会进行 resultMap 的自动构建并注入) |

关于autoResultMap的说明:
mp会自动构建一个ResultMap并注入到mybatis里(一般用不上).下面讲两句: 因为mp底层是mybatis,所以一些mybatis的常识你要知道,mp只是帮你注入了常用crud到mybatis里 注入之前可以说是动态的(根据你entity的字段以及注解变化而变化),但是注入之后是静态的(等于你写在xml的东西) 而对于直接指定typeHandler,mybatis只支持你写在2个地方:

1. 定义在resultMap里,只作用于select查询的返回结果封装
2. 定义在insert和updatesql的#{property}里的property后面(例:#{property,typehandler=xxx.xxx.xxx}),只作用于设置值 而除了这两种直接指定typeHandler,mybatis有一个全局的扫描你自己的typeHandler包的配置,这是根据你的property的类型去找typeHandler并使用.

   @TableId

• 描述：主键注解 | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | :—-: | | value | String | 否 | “” | 主键字段名 | | type | Enum | 否 | IdType.NONE | 主键类型 |

IdType

@TableField

• 描述：字段注解(非主键) | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | :—-: | | value | String | 否 | “” | 字段名 | | el | String | 否 | “” | 映射为原生 #{ ... } 逻辑,相当于写在 xml 里的 #{ ... } 部分 | | exist | boolean | 否 | true | 是否为数据库表字段 | | condition | String | 否 | “” | 字段 where 实体查询比较条件,有值设置则按设置的值为准,没有则为默认全局的 %s=#{%s},参考 | | update | String | 否 | “” | 字段 update set 部分注入, 例如：update=”%s+1”：表示更新时会set version=version+1(该属性优先级高于 el 属性) | | insertStrategy | Enum | N | DEFAULT | 举例：NOT_NULL: insert into table_a(<if test="columnProperty != null">column</if>) values (<if test="columnProperty != null">#{columnProperty}</if>) | | updateStrategy | Enum | N | DEFAULT | 举例：IGNORED: update table_a set column=#{columnProperty} | | whereStrategy | Enum | N | DEFAULT | 举例：NOT_EMPTY: where <if test="columnProperty != null and columnProperty!=''">column=#{columnProperty}</if> | | fill | Enum | 否 | FieldFill.DEFAULT | 字段自动填充策略 | | select | boolean | 否 | true | 是否进行 select 查询 | | keepGlobalFormat | boolean | 否 | false | 是否保持使用全局的 format 进行处理 | | jdbcType | JdbcType | 否 | JdbcType.UNDEFINED | JDBC类型 (该默认值不代表会按照该值生效) | | typeHandler | Class<? extends TypeHandler> | 否 | UnknownTypeHandler.class | 类型处理器 (该默认值不代表会按照该值生效) | | numericScale | String | 否 | “” | 指定小数点后保留的位数 |

关于jdbcType和typeHandler以及numericScale的说明:
numericScale只生效于 update 的sql. jdbcType和typeHandler如果不配合@TableName#autoResultMap = true一起使用,也只生效于 update 的sql. 对于typeHandler如果你的字段类型和set进去的类型为equals关系,则只需要让你的typeHandler让Mybatis加载到即可,不需要使用注解

FieldStrategy

FieldFill

@Version

• 描述：乐观锁注解、标记 @Verison 在字段上

  @EnumValue

• 描述：通枚举类注解(注解在枚举字段上)

  @TableLogic

• 描述：表字段逻辑处理注解（逻辑删除） | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | :—-: | | value | String | 否 | “” | 逻辑未删除值 | | delval | String | 否 | “” | 逻辑删除值 |

@SqlParser

• 描述：租户注解,支持method上以及mapper接口上 | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | :—-: | | filter | boolean | 否 | false | true: 表示过滤SQL解析，即不会进入ISqlParser解析链，否则会进解析链并追加例如tenant_id等条件 |

@KeySequence

• 描述：序列主键策略 oracle
• 属性：value、resultMap | 属性 | 类型 | 必须指定 | 默认值 | 描述 | | :—-: | :—-: | :—-: | :—-: | :—-: | | value | String | 否 | “” | 序列名 | | clazz | Class | 否 | Long.class | id的类型, 可以指定String.class，这样返回的Sequence值是字符串”1” |

核心功能

代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
特别说明:
自定义模板有哪些可用参数？Github Gitee AbstractTemplateEngine 类中方法 getObjectMap 返回 objectMap 的所有值都可用。
演示效果图：

// 演示例子，执行 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.isNotEmpty(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("jobob");
        gc.setOpen(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);
        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/ant?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("密码");
        mpg.setDataSource(dsc);
        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        pc.setParent("com.baomidou.ant");
        mpg.setPackageInfo(pc);
        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录");
                return false;
            }
        });
        */
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();
        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        // 公共父类
        strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 写于父类中的公共字段
        strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}

使用教程

添加依赖

MyBatis-Plus 从 3.0.3 之后移除了代码生成器与模板引擎的默认依赖，需要手动添加相关依赖：

• 添加 代码生成器 依赖

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

• 添加 模板引擎 依赖，MyBatis-Plus 支持 Velocity（默认）、Freemarker、Beetl，用户可以选择自己熟悉的模板引擎，如果都不满足您的要求，可以采用自定义模板引擎。
  Velocity（默认）：

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

• Freemarker：

  <dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.29</version>
  </dependency>

• Beetl：

  <dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>3.0.16.RELEASE</version>
  </dependency>

• 注意！如果您选择了非默认引擎，需要在 AutoGenerator 中 设置模板引擎。

  AutoGenerator generator = new AutoGenerator();
  // set freemarker engine
  generator.setTemplateEngine(new FreemarkerTemplateEngine());
  // set beetl engine
  generator.setTemplateEngine(new BeetlTemplateEngine());
  // set custom engine (reference class is your custom engine class)
  generator.setTemplateEngine(new CustomTemplateEngine());
  // other config
  ...

  编写配置

  MyBatis-Plus 的代码生成器提供了大量的自定义参数供用户选择，能够满足绝大部分人的使用需求。

• 配置 GlobalConfig

  GlobalConfig globalConfig = new GlobalConfig();
  globalConfig.setOutputDir(System.getProperty("user.dir") + "/src/main/java");
  globalConfig.setAuthor("jobob");
  globalConfig.setOpen(false);

• 配置 DataSourceConfig

  DataSourceConfig dataSourceConfig = new DataSourceConfig();
  dataSourceConfig.setUrl("jdbc:mysql://localhost:3306/ant?useUnicode=true&useSSL=false&characterEncoding=utf8");
  dataSourceConfig.setDriverName("com.mysql.jdbc.Driver");
  dataSourceConfig.setUsername("root");
  dataSourceConfig.setPassword("password");

  自定义模板引擎

  请继承类 com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine

  自定义代码模板

  //指定自定义模板路径, 位置：/resources/templates/entity2.java.ftl(或者是.vm)
  //注意不要带上.ftl(或者是.vm), 会根据使用的模板引擎自动识别
  TemplateConfig templateConfig = new TemplateConfig()
    .setEntity("templates/entity2.java");
  AutoGenerator mpg = new AutoGenerator();
  //配置自定义模板
  mpg.setTemplate(templateConfig);

  自定义属性注入

  InjectionConfig injectionConfig = new InjectionConfig() {
    //自定义属性注入:abc
    //在.ftl(或者是.vm)模板中，通过${cfg.abc}获取属性
    @Override
    public void initMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-mp");
        this.setMap(map);
    }
  };
  AutoGenerator mpg = new AutoGenerator();
  //配置自定义属性注入
  mpg.setCfg(injectionConfig);

  entity2.java.ftl
  自定义属性注入abc=${cfg.abc}
  entity2.java.vm
  自定义属性注入abc=$!{cfg.abc}

  字段其他信息查询注入

  

  new DataSourceConfig().setDbQuery(new MySqlQuery() {
    /**
     * 重写父类预留查询自定义字段<br>
     * 这里查询的 SQL 对应父类 tableFieldsSql 的查询字段，默认不能满足你的需求请重写它<br>
     * 模板中调用：  table.fields 获取所有字段信息，
     * 然后循环字段获取 field.customMap 从 MAP 中获取注入字段如下  NULL 或者 PRIVILEGES
     */
    @Override
    public String[] fieldCustom() {
        return new String[]{"NULL", "PRIVILEGES"};
    }
  })

  CRUD 接口

  Service CRUD 接口

  说明:

• 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，

• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

  Save

  // 插入一条记录（选择字段，策略插入）
  boolean save(T entity);
  // 插入（批量）
  boolean saveBatch(Collection<T> entityList);
  // 插入（批量）
  boolean saveBatch(Collection<T> entityList, int batchSize);

  参数说明

  | 类型 | 参数名 | 描述 | | :—-: | :—-: | :—-: | | T | entity | 实体对象 | | Collection | entityList | 实体对象集合 | | int | batchSize | 插入批次数量 |

SaveOrUpdate

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

参数说明

Remove

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

参数说明

Update

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereEntity 条件，更新记录
boolean update(T entity, Wrapper<T> updateWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

参数说明

Get

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

参数说明

List

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

参数说明

Page

// 无条件翻页查询
IPage<T> page(IPage<T> page);
// 翻页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件翻页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 翻页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

参数说明

Count

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

参数说明

Chain

query

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery(); 
// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

update

// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();
// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

Mapper CRUD 接口

说明:

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

  Insert

  // 插入一条记录
  int insert(T entity);

  参数说明

  | 类型 | 参数名 | 描述 | | :—-: | :—-: | :—-: | | T | entity | 实体对象 |

Delete

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

参数说明

Update

// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

参数说明

Select

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

参数说明

mapper 层 选装件

说明:
选装件位于 com.baomidou.mybatisplus.extension.injector.methods.additional 包下 需要配合Sql 注入器使用案例
使用详细见源码注释

AlwaysUpdateSomeColumnById

int alwaysUpdateSomeColumnById(T entity);

insertBatchSomeColumn

int insertBatchSomeColumn(List<T> entityList);

deleteByIdWithFill

int deleteByIdWithFill(T entity);

条件构造器

说明:

• 以下出现的第一个入参boolean condition表示该条件是否加入最后生成的sql中
• 以下代码块内的多个方法均为从上往下补全个别boolean类型的入参,默认为true
• 以下出现的泛型Param均为Wrapper的子类实例(均具有AbstractWrapper的所有方法)
• 以下方法在入参中出现的R为泛型,在普通wrapper中是String,在LambdaWrapper中是函数(例:Entity::getId,Entity为实体类,getId为字段id的getMethod)
• 以下方法入参中的R column均表示数据库字段,当R具体类型为String时则为数据库字段名(字段名是数据库关键字的自己用转义符包裹!)!而不是实体类数据字段名!!!,另当R具体类型为SFunction时项目runtime不支持eclipse自家的编译器!!!
• 以下举例均为使用普通wrapper,入参为Map和List的均以json形式表现!
• 使用中如果入参的Map或者List为空,则不会加入最后生成的sql中!!!
• 有任何疑问就点开源码看,看不懂函数的点击我学习新知识

警告:
不支持以及不赞成在 RPC 调用中把 Wrapper 进行传输

1. wrapper 很重
2. 传输 wrapper 可以类比为你的 controller 用 map 接收值(开发一时爽,维护火葬场)
3. 正确的 RPC 调用姿势是写一个 DTO 进行传输,被调用方再根据 DTO 执行相应的操作
4. 我们拒绝接受任何关于 RPC 传输 Wrapper 报错相关的 issue 甚至 pr

   AbstractWrapper

   说明:
   QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类
   用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件
   注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为

   allEq

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

• 全部eq(或个别isNull)

个别参数说明:
params : key为数据库字段名,value为字段值
null2IsNull : 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的

• 例1: allEq({id:1,name:"老王",age:null})—->id = 1 and name = '老王' and age is null
• 例2: allEq({id:1,name:"老王",age:null}, false)—->id = 1 and name = '老王'

allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)

个别参数说明:
filter : 过滤函数,是否允许字段传入比对条件中
params 与 null2IsNull : 同上

• 例1: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})—->name = '老王' and age is null
• 例2: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)—->name = '老王'

  eq

eq(R column, Object val)
eq(boolean condition, R column, Object val)

• 等于 =

• 例: eq("name", "老王")—->name = '老王'

  ne

  ne(R column, Object val)
  ne(boolean condition, R column, Object val)

• 不等于 <>

• 例: ne("name", "老王")—->name <> '老王'

  gt

  gt(R column, Object val)
  gt(boolean condition, R column, Object val)

• 大于 >

• 例: gt("age", 18)—->age > 18

  ge

ge(R column, Object val)
ge(boolean condition, R column, Object val)

• 大于等于 >=
• 例: ge("age", 18)—->age >= 18

  lt

lt(R column, Object val)
lt(boolean condition, R column, Object val)

• 小于 <
• 例: lt("age", 18)—->age < 18

  le

le(R column, Object val)
le(boolean condition, R column, Object val)

• 小于等于 <=
• 例: le("age", 18)—->age <= 18

  between

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

• BETWEEN 值1 AND 值2
• 例: between("age", 18, 30)—->age between 18 and 30

  notBetween

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

• NOT BETWEEN 值1 AND 值2
• 例: notBetween("age", 18, 30)—->age not between 18 and 30

  like

like(R column, Object val)
like(boolean condition, R column, Object val)

• LIKE ‘%值%’
• 例: like("name", "王")—->name like '%王%'

  notLike

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

• NOT LIKE ‘%值%’
• 例: notLike("name", "王")—->name not like '%王%'

  likeLeft

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

• LIKE ‘%值’
• 例: likeLeft("name", "王")—->name like '%王'

  likeRight

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

• LIKE ‘值%’
• 例: likeRight("name", "王")—->name like '王%'

  isNull

isNull(R column)
isNull(boolean condition, R column)

• 字段 IS NULL
• 例: isNull("name")—->name is null

  isNotNull

isNotNull(R column)
isNotNull(boolean condition, R column)

• 字段 IS NOT NULL
• 例: isNotNull("name")—->name is not null

  in

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

• 字段 IN (value.get(0), value.get(1), …)
• 例: in("age",{1,2,3})—->age in (1,2,3)

in(R column, Object... values)
in(boolean condition, R column, Object... values)

• 字段 IN (v0, v1, …)
• 例: in("age", 1, 2, 3)—->age in (1,2,3)

  notIn

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

• 字段 IN (value.get(0), value.get(1), …)
• 例: notIn("age",{1,2,3})—->age not in (1,2,3)

notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

• 字段 NOT IN (v0, v1, …)
• 例: notIn("age", 1, 2, 3)—->age not in (1,2,3)

  inSql

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

• 字段 IN ( sql语句 )
• 例: inSql("age", "1,2,3,4,5,6")—->age in (1,2,3,4,5,6)
• 例: inSql("id", "select id from table where id < 3")—->id in (select id from table where id < 3)

  notInSql

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

• 字段 NOT IN ( sql语句 )
• 例: notInSql("age", "1,2,3,4,5,6")—->age not in (1,2,3,4,5,6)
• 例: notInSql("id", "select id from table where id < 3")—->age not in (select id from table where id < 3)

  groupBy

groupBy(R... columns)
groupBy(boolean condition, R... columns)

• 分组：GROUP BY 字段, …
• 例: groupBy("id", "name")—->group by id,name

  orderByAsc

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

• 排序：ORDER BY 字段, … ASC
• 例: orderByAsc("id", "name")—->order by id ASC,name ASC

  orderByDesc

orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

• 排序：ORDER BY 字段, … DESC

• 例: orderByDesc("id", "name")—->order by id DESC,name DESC

  orderBy

  orderBy(boolean condition, boolean isAsc, R... columns)

• 排序：ORDER BY 字段, …

• 例: orderBy(true, true, "id", "name")—->order by id ASC,name ASC

  having

having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

• HAVING ( sql语句 )
• 例: having("sum(age) > 10")—->having sum(age) > 10
• 例: having("sum(age) > {0}", 11)—->having sum(age) > 11

  or

or()
or(boolean condition)

• 拼接 OR

注意事项:
主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

• 例: eq("id",1).or().eq("name","老王")—->id = 1 or name = '老王'

or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

• OR 嵌套
• 例: or(i -> i.eq("name", "李白").ne("status", "活着"))—->or (name = '李白' and status <> '活着')

  and

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

• AND 嵌套
• 例: and(i -> i.eq("name", "李白").ne("status", "活着"))—->and (name = '李白' and status <> '活着')

  nested

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

• 正常嵌套 不带 AND 或者 OR
• 例: nested(i -> i.eq("name", "李白").ne("status", "活着"))—->(name = '李白' and status <> '活着')

  apply

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

• 拼接 sql

注意事项:
该方法可用于数据库函数 动态入参的params对应前面applySql内部的{index}部分.这样是不会有sql注入风险的,反之会有!

• 例: apply("id = 1")—->id = 1
• 例: apply("date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")—->date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
• 例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08")—->date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")

  last

last(String lastSql)
last(boolean condition, String lastSql)

• 无视优化规则直接拼接到 sql 的最后

注意事项:
只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

• 例: last("limit 1")

  exists

exists(String existsSql)
exists(boolean condition, String existsSql)

• 拼接 EXISTS ( sql语句 )
• 例: exists("select id from table where age = 1")—->exists (select id from table where age = 1)

  notExists

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

• 拼接 NOT EXISTS ( sql语句 )
• 例: notExists("select id from table where age = 1")—->not exists (select id from table where age = 1)

  QueryWrapper

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

  select

select(String... sqlSelect)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

• 设置查询字段

说明:
以上方分法为两类.
第二类方法为:过滤查询字段(主键除外),入参不包含 class 的调用前需要wrapper内的entity属性有值! 这两类方法重复调用以最后一次为准

• 例: select("id", "name", "age")

• 例: select(i -> i.getProperty().startsWith("test"))

  excludeColumns @Deprecated

• 排除查询字段

已从3.0.5版本上移除此方法!

UpdateWrapper

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

set

set(String column, Object val)
set(boolean condition, String column, Object val)

• SQL SET 字段
• 例: set("name", "老李头")
• 例: set("name", "")—->数据库字段值变为空字符串

• 例: set("name", null)—->数据库字段值变为null

  setSql

  setSql(String sql)

• 设置 SET 部分 SQL

• 例: setSql("name = '老李头'")

  lambda

• 获取 LambdaWrapper
  在QueryWrapper中是获取LambdaQueryWrapper
  在UpdateWrapper中是获取LambdaUpdateWrapper

  使用 Wrapper 自定义SQL

  需求来源:
  在使用了mybatis-plus之后, 自定义SQL的同时也想使用Wrapper的便利应该怎么办？ 在mybatis-plus版本3.0.7得到了完美解决 版本需要大于或等于3.0.7, 以下两种方案取其一即可

  Service.java

  mysqlMapper.getAll(Wrappers.<MysqlData>lambdaQuery().eq(MysqlData::getGroup, 1));

  方案一 注解方式 Mapper.java

  @Select("select * from mysql_data ${ew.customSqlSegment}")
  List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

  方案二 XML形式 Mapper.xml

  <select id="getAll" resultType="MysqlData">
    SELECT * FROM mysql_data ${ew.customSqlSegment}
  </select>

  分页插件

  示例工程：
  👉 mybatis-plus-sample-pagination

  <!-- spring xml 方式 -->
  <property name="plugins">
    <array>
        <bean class="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor">
            <property name="sqlParser" ref="自定义解析类、可以没有"/>
            <property name="dialectClazz" value="自定义方言类、可以没有"/>
            <!-- COUNT SQL 解析.可以没有 -->
            <property name="countSqlParser" ref="countSqlParser"/>
        </bean>
    </array>
  </property>
  <bean id="countSqlParser" class="com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize">
    <!-- 设置为 true 可以优化部分 left join 的sql -->
    <property name="optimizeJoin" value="true"/>
  </bean>

  //Spring boot方式
  @EnableTransactionManagement
  @Configuration
  @MapperScan("com.baomidou.cloud.service.*.mapper*")
  public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
  }

  XML 自定义分页

• UserMapper.java 方法内容

  public interface UserMapper {//可以继承或者不继承BaseMapper
    /**
     * <p>
     * 查询 : 根据state状态查询用户列表，分页显示
     * </p>
     *
     * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象)
     * @param state 状态
     * @return 分页对象
     */
    IPage<User> selectPageVo(Page<?> page, Integer state);
  }

• UserMapper.xml 等同于编写一个普通 list 查询，mybatis-plus 自动替你分页

  <select id="selectPageVo" resultType="com.baomidou.cloud.entity.UserVo">
    SELECT id,name FROM user WHERE state=#{state}
  </select>

• UserServiceImpl.java 调用分页方法

  public IPage<User> selectUserPage(Page<User> page, Integer state) {
    // 不进行 count sql 优化，解决 MP 无法自动优化 SQL 问题，这时候你需要自己查询 count 部分
    // page.setOptimizeCountSql(false);
    // 当 total 为小于 0 或者设置 setSearchCount(false) 分页插件不会进行 count 查询
    // 要点!! 分页返回的对象与传入的对象是同一个
    return userMapper.selectPageVo(page, state);
  }

  Sequence主键

  主键生成策略必须使用INPUT
  支持父类定义@KeySequence子类继承使用
  支持主键类型指定(3.3.0开始自动识别主键类型)
  内置支持：

• DB2KeyGenerator

• H2KeyGenerator
• KingbaseKeyGenerator
• OracleKeyGenerator
• PostgreKeyGenerator

如果内置支持不满足你的需求，可实现IKeyGenerator接口来进行扩展.
举个栗子

@KeySequence(value = "SEQ_ORACLE_STRING_KEY", clazz = String.class)
public class YourEntity {
    @TableId(value = "ID_STR", type = IdType.INPUT)
    private String idStr;
}

Spring-Boot

方式一：使用配置类

@Bean
public IKeyGenerator keyGenerator() {
    return new H2KeyGenerator();
}

方式二：通过MybatisPlusPropertiesCustomizer自定义

@Bean
public MybatisPlusPropertiesCustomizer plusPropertiesCustomizer() {
    return plusProperties -> plusProperties.getGlobalConfig().getDbConfig().setKeyGenerator(new H2KeyGenerator());
}

Spring

方式一: XML配置

<bean id="globalConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig">
   <property name="dbConfig" ref="dbConfig"/>
</bean>
<bean id="dbConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig.DbConfig">
   <property name="keyGenerator" ref="keyGenerator"/>
</bean>
<bean id="keyGenerator" class="com.baomidou.mybatisplus.extension.incrementer.H2KeyGenerator"/>

方式二：注解配置

@Bean
public GlobalConfig globalConfig() {
    GlobalConfig conf = new GlobalConfig();
    conf.setDbConfig(new GlobalConfig.DbConfig().setKeyGenerator(new H2KeyGenerator()));
    return conf;
}

自定义ID生成器

自3.3.0开始,默认使用雪花算法+UUID(不含中划线)
自定义示例工程：

• spring-boot示例 ：传送门 | 方法 | 主键生成策略 | 主键类型 | 说明 | | —- | —- | —- | —- | | nextId | ASSIGN_ID，ID_WORKER，ID_WORKER_STR | Long,Integer,String | 支持自动转换为String类型，但数值类型不支持自动转换，需精准匹配，例如返回Long，实体主键就不支持定义为Integer | | nextUUID | ASSIGN_UUID，UUID | String | 默认不含中划线的UUID生成 |

Spring-Boot

方式一：声明为Bean供Spring扫描注入

@Component
public class CustomIdGenerator implements IdentifierGenerator {
    @Override
    public Long nextId(Object entity) {
          //可以将当前传入的class全类名来作为bizKey,或者提取参数来生成bizKey进行分布式Id调用生成.
          String bizKey = entity.getClass().getName();
        //根据bizKey调用分布式ID生成
        long id = ....;
          //返回生成的id值即可.
        return id;
    }
}

方式二：使用配置类

@Bean
public IdentifierGenerator idGenerator() {
    return new CustomIdGenerator();
}

方式三：通过MybatisPlusPropertiesCustomizer自定义

@Bean
public MybatisPlusPropertiesCustomizer plusPropertiesCustomizer() {
    return plusProperties -> plusProperties.getGlobalConfig().setIdentifierGenerator(new CustomIdGenerator());
}

Spring

方式一: XML配置

<bean name="customIdGenerator" class="com.baomidou.samples.incrementer.CustomIdGenerator"/>
<bean id="globalConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig">
        <property name="identifierGenerator" ref="customIdGenerator"/>
</bean>

方式二：注解配置

@Bean
public GlobalConfig globalConfig() {
    GlobalConfig conf = new GlobalConfig();
    conf.setIdentifierGenerator(new CustomIdGenerator());
    return conf;
}

插件扩展

热加载

3.0.6版本上移除了该功能,不过最新快照版已加回来并打上废弃标识,3.1.0版本上已完全移除

开启动态加载 mapper.xml

• 多数据源配置多个 MybatisMapperRefresh 启动 bean

• 默认情况下,eclipse保存会自动编译,idea需自己手动编译一次

  参数说明：
      sqlSessionFactory:session工厂
      mapperLocations:mapper匹配路径
      enabled:是否开启动态加载  默认:false
      delaySeconds:项目启动延迟加载时间  单位：秒  默认:10s
      sleepSeconds:刷新时间间隔  单位：秒 默认:20s
  提供了两个构造,挑选一个配置进入spring配置文件即可：
  构造1:
    <bean class="com.baomidou.mybatisplus.spring.MybatisMapperRefresh">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
        <constructor-arg name="mapperLocations" value="classpath*:mybatis/mappers/*/*.xml"/>
        <constructor-arg name="enabled" value="true"/>
    </bean>
  构造2:
    <bean class="com.baomidou.mybatisplus.spring.MybatisMapperRefresh">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
        <constructor-arg name="mapperLocations" value="classpath*:mybatis/mappers/*/*.xml"/>
        <constructor-arg name="delaySeconds" value="10"/>
        <constructor-arg name="sleepSeconds" value="20"/>
        <constructor-arg name="enabled" value="true"/>
    </bean>

  逻辑删除

  SpringBoot 配置方式：

• application.yml 加入配置(如果你的默认值和mp默认的一样,该配置可无):

  mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  #全局逻辑删除字段值 3.3.0开始支持，详情看下面。
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

• 注册 Bean(3.1.1开始不再需要这一步)：

  import com.baomidou.mybatisplus.core.injector.ISqlInjector;
  import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  @Configuration
  public class MyBatisPlusConfiguration {
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }
  }

• 实体类字段上加上@TableLogic注解

  @TableLogic
  private Integer deleted;

• 效果: 使用mp自带方法删除和查找都会附带逻辑删除功能 (自己写的xml不会)

  example
  删除时 update user set deleted=1 where id =1 and deleted=0
  查找时 select * from user where deleted=0

• 全局逻辑删除: 3.3.0开始支持
  如果公司代码比较规范，比如统一了全局都是flag为逻辑删除字段。
  使用此配置则不需要在实体类上添加 @TableLogic。
  但如果实体类上有 @TableLogic 则以实体上的为准，忽略全局。 即先查找注解再查找全局，都没有则此表没有逻辑删除。

  mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  #全局逻辑删除字段值

  附件说明

• 逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案，但实际就是删除。

• 如果你需要再查出来就不应使用逻辑删除，而是以一个状态去表示。

如： 员工离职，账号被锁定等都应该是一个状态字段，此种场景不应使用逻辑删除。

• 若确需查找删除数据，如老板需要查看历史所有数据的统计汇总信息，请单独手写sql。

  通用枚举

  解决了繁琐的配置，让 mybatis 优雅的使用枚举属性！

  自3.1.0开始，如果你无需使用原生枚举，可配置默认枚举来省略扫描通用枚举配置 默认枚举配置

  • 升级说明:
    3.1.0 以下版本改变了原生默认行为,升级时请将默认枚举设置为EnumOrdinalTypeHandler
    
  • 影响用户:
    实体中使用原生枚举
    
  • 其他说明:
    配置枚举包扫描的时候能提前注册使用注解枚举的缓存
    

1、声明通用枚举属性

方式一： 使用 @EnumValue 注解枚举属性 完整示例

public enum GradeEnum {
    PRIMARY(1, "小学"),  SECONDORY(2, "中学"),  HIGH(3, "高中");
    GradeEnum(int code, String descp) {
        this.code = code;
        this.descp = descp;
    }
    @EnumValue//标记数据库存的值是code
    private final int code;
    //。。。
}

方式二： 枚举属性，实现 IEnum 接口如下：

public enum AgeEnum implements IEnum<Integer> {
    ONE(1, "一岁"),
    TWO(2, "二岁"),
    THREE(3, "三岁");
    private int value;
    private String desc;
    @Override
    public Integer getValue() {
        return this.value;
    }
}