官方文档: mybatis-plus 官方文档

一、添加依赖pom.xml

  1. <!-- mysql驱动 -->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5. </dependency>
  6. <!-- druid 连接池 -->
  7. <dependency>
  8.     <groupId>com.alibaba</groupId>
  9.     <artifactId>druid-spring-boot-starter</artifactId>
  10.     <version>1.1.10</version>
  11. </dependency>
  12. <!-- mybatis-plus -->
  13. <dependency>
  14.     <groupId>com.baomidou</groupId>
  15.     <artifactId>mybatis-plus-boot-starter</artifactId>
  16.     <version>3.1.0</version>
  17. </dependency>
  18. <!-- mybatis plus 代码生成器依赖 -->
  19. <dependency>
  20.     <groupId>com.baomidou</groupId>
  21.     <artifactId>mybatis-plus-generator</artifactId>
  22.     <version>3.1.0</version>
  23. </dependency>
  24. <!-- 代码生成器模板 -->
  25. <dependency>
  26.     <groupId>org.freemarker</groupId>
  27.     <artifactId>freemarker</artifactId>
  28. </dependency>
  31. <!-- 防止打包没有打入mapper.xml文件 -->
  32.  <resources>
  33.             <resource>
  34.                 <directory>src/main/resources</directory>
  35.                 <filtering>true</filtering>
  36.                 <!-- 打包时所包含得文件 -->
  37.                 <includes>
  38.                     <include>application.yml</include>
  39.                     <include>mapper/*.xml</include>
  40.                     <include>config/application-${env}.yml</include>
  41.                 </includes>
  42.             </resource>
  43.         </resources>

二、application.yml添加配置

  1. # 数据库相关
  2. spring:
  3.   #数据库配置
  4.   datasource:
  5.     url: jdbc:mysql://IP:3306/demo?useUnicode=true&useSSL=false&characterEncoding=utf-8
  6.     username: name
  7.     password: password
  8.     # 使用druid数据源
  9.     type: com.alibaba.druid.pool.DruidDataSource
  10.     driver-class-name: com.mysql.jdbc.Driver
  11.     # 数据源配置
  12.     druid:
  13.       # druid连接池监控
  14.       stat-view-servlet:
  15.         enabled: true
  16.         url-pattern: /druid/*
  17.         login-username: admin
  18.         login-password: admin
  19.         # 初始化时建立物理连接的个数
  20.         initial-size: 5
  21.         # 最大连接池数量
  22.         max-active: 30
  23.         # 最小连接池数量
  24.         min-idle: 5
  25.         # 获取连接时最大等待时间，单位毫秒
  26.         max-wait: 60000
  27.         # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
  28.         time-between-eviction-runs-millis: 60000
  29.         # 连接保持空闲而不被驱逐的最小时间
  30.         min-evictable-idle-time-millis: 300000
  31.         # 用来检测连接是否有效的sql，要求是一个查询语句
  32.         validation-query: select count(*) from dual
  33.         # 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
  34.         test-while-idle: true
  35.         # 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
  36.         test-on-borrow: false
  37.         # 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
  38.         test-on-return: false
  39.         # 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
  40.         pool-prepared-statements: false
  41.         # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
  42.         max-pool-prepared-statement-per-connection-size: 50
  43.         # 配置监控统计拦截的filters，去掉后监控界面sql无法统计
  44.         filters: stat,wall
  45.         # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
  46.         connection-properties:
  47.           druid.stat.mergeSql: true
  48.           druid.stat.slowSqlMillis: 500
  49.         # 合并多个DruidDataSource的监控数据
  50.         use-global-data-source-stat: true
  51.         filter:
  52.           stat:
  53.             log-slow-sql: true
  54.             slow-sql-millis: 1000
  55.             merge-sql: true
  56.           wall:
  57.             config:
  58.               multi-statement-allow: true
  60. # mybatis-plus 配置
  61. mybatis-plus:
  62.   configuration:
  63.     map-underscore-to-camel-case: true
  64.     auto-mapping-behavior: full
  65.     # 日志打印
  66.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  67.   # 配置 Mapper 对应的 XML 文件路径
  68.   mapper-locations: classpath*:mapper/**/*Mapper.xml
  72.   # 参考配置
  73.   mybatis-plus:
  74.   mapper-locations: classpath:/mapping/**/*.xml
  75.   global-config:
  76.     db-config:
  77.       #刷新mapper 调试神器
  78.       #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
  79.       id-type: auto
  80.       #驼峰下划线转换
  81.       capital-mode: true
  82.       #逻辑删除配置
  83.       sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
  84.       logic-delete-value: 1
  85.       logic-not-delete-value: 0
  86.       # 配置数据源
  87.       db-type: mysql
  88.       # 操作是否判断null
  89.       field-strategy: not-null
  90.   configuration:
  91.     map-underscore-to-camel-case: true
  92.     cache-enabled: false
  95.  mybatis-plus:
  96.   config-location: xxxxxxx  # MyBatis 配置文件位置  ---String 默认：null 
  97.   mapper-locations: # MyBatis Mapper 所对应的 XML 文件位置  ---String[]  默认： [] 
  98.   - classpath*:/mapper/comm
  99.   - classpath*:/mapper/member
  100.   type-aliases-package: bertram.wang.domain.entity # 实体包   --- String
  101.   type-aliases-super-type: bertram.wang.domain.entity.BaseEntity # 实体的父类类名 Class<?>
  102.   type-handlers-package: xxxxxxxx # SqlSessionFactoryBean 会把该包下面的类注册为对应的 TypeHandler ---String 默认：null 
  103.   typeEnumsPackage: xxxxx # 让实体类字段能够简单快捷的使用枚举属性  ---String 默认：null 
  104.   check-config-location: false # 检查mybatis xml 文件的存在
  105.   executor-type: simple # 知道mybatis的执行器
  106.   # configuration-properties:  # 指定外部化 MyBatis Properties 配置，通过该配置可以抽离配置，实现不同环境的配置部署
  107.   configuration: # 本部分（Configuration）的配置大都为 MyBatis 原生支持的配置
  108.     map-underscore-to-camel-case: true #　 是否开启自动驼峰命名规则（camel case）映射
  109.     default-enum-type-handler: org.apache.ibatis.type.EnumTypeHandler 
  110.     aggressive-lazy-loading: true #当设置为 true 的时候，懒加载的对象可能被任何懒属性全部加载，否则，每个属性都按需加载。需要和 lazyLoadingEnabled 一起使用
  111.     auto-mapping-behavior: partial # 自动映射策略
  112.     auto-mapping-unknown-column-behavior: none # 自动映射遇到未知列时的处理策略
  113.     cache-enabled: true # 映射器缓存开启
  114.     call-setters-on-nulls: false # 空值的列
  115.     configuration-factory: xxxxxxx # 指定一个提供 Configuration 实例的工厂类 (从 3.2.3 版本开始)
  116.   global-config:
  117.     banner: true # 控制台 print mybatis-plus 的 LOGO
  118.     sql-parser-cache: true # 开启缓存
  119.     worker-id: 1234312 # ID的部分值
  120.     datacenter-id: 1313 # 数据标识ID部分
  121.     super-mapper-class: com.baomidou.mybatisplus.core.mapper.Mapper.class # 通用Mapper父类
  122.     db-config:
  123.       db-type: mysql # 数据库类型
  124.       id-type: auto  # id策略
  125.       table-prefix: t_ # 表前缀
  126.       table-underline: true # 表明下划线命名
  127.       column-like: false # 是否开启 LIKE 查询，即根据 entity 自动生成的 where 条件中 String 类型字段 是否使用 LIKE，默认不开启
  128.       capital-mode: false # 不开启大写命名
  129.       logic-delete-value: 1 # 逻辑已删除值
  130.       logic-not-delete-value: 0 #逻辑未删除值

三、application配置@MapperScan

  1. @MapperScan("com.alibaba.demo.mapper")
  2. @EnableConfigurationProperties({DemoBeanConfig.class})
  3. @SpringBootApplication
  4. public class DemoApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(DemoApplication.class, args);
  7.     }
  8. }

到这里就引入了MyBatis-Plus了。

四、代码生成器

自动生成entity，mapper等文件，使用代码生成器来自动生成对应的文件了。需要修改几个地方：
1、数据库连接
2、文件需要放置的文件夹地址。
具体代码：

  1. package com.alibaba.demo;
  3. import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
  4. import com.baomidou.mybatisplus.core.toolkit.StringPool;
  5. import com.baomidou.mybatisplus.core.toolkit.StringUtils;
  6. import com.baomidou.mybatisplus.generator.AutoGenerator;
  7. import com.baomidou.mybatisplus.generator.InjectionConfig;
  8. import com.baomidou.mybatisplus.generator.config.*;
  9. import com.baomidou.mybatisplus.generator.config.po.TableInfo;
  10. import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
  11. import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.Scanner;
  16. /**
  17.  * 代码自动生成工具
  18.  * 执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
  19.  * @author shf
  20.  */
  21. public class CodeGenerator {
  22.     /**
  23.      * <p>
  24.      * 读取控制台内容
  25.      * </p>
  26.      */
  27.     public static String scanner(String tip) {
  28.         Scanner scanner = new Scanner(System.in);
  29.         StringBuilder help = new StringBuilder();
  30.         help.append("请输入" + tip + "：");
  31.         System.out.println(help.toString());
  32.         if (scanner.hasNext()) {
  33.             String ipt = scanner.next();
  34.             if (StringUtils.isNotEmpty(ipt)) {
  35.                 return ipt;
  36.             }
  37.         }
  38.         throw new MybatisPlusException("请输入正确的" + tip + "！");
  39.     }
  41.     public static void main(String[] args) {
  42.         // 代码生成器
  43.         AutoGenerator mpg = new AutoGenerator();
  44.         // 全局配置
  45.         GlobalConfig gc = new GlobalConfig();
  46.         // TODO 工程目录，需要手动填写
  47.         String projectPath = "D:/workSpace/技术分享/6.springboot搭建工程/demo";
  48.         gc.setOutputDir(projectPath + "/src/main/java");
  49.         gc.setAuthor("史恒飞");
  50.         gc.setOpen(false);
  51.         // service 命名方式
  52.         gc.setServiceName("%sService");
  53.         // service impl 命名方式
  54.         gc.setServiceImplName("%sServiceImpl");
  55.         // mapper文件命名，注意 %s 会自动填充表实体属性！
  56.         gc.setMapperName("%sMapper");
  57.         // xml文件结尾
  58.         gc.setXmlName("%sMapper");
  59.         gc.setFileOverride(true);
  60.         gc.setActiveRecord(true);
  61.         // XML 二级缓存
  62.         gc.setEnableCache(false);
  63.         // XML ResultMap
  64.         gc.setBaseResultMap(true);
  65.         // XML columList
  66.         gc.setBaseColumnList(false);
  67.         // gc.setSwagger2(true); 实体属性 Swagger2 注解
  68.         mpg.setGlobalConfig(gc);
  69.         // TODO 数据源配置
  70.         DataSourceConfig dsc = new DataSourceConfig();
  71.         dsc.setUrl("jdbc:mysql://47.112.96.83:3306/demo?useUnicode=true&useSSL=false&characterEncoding=utf-8");
  72.         // dsc.setSchemaName("public");
  73.         dsc.setDriverName("com.mysql.jdbc.Driver");
  74.         dsc.setUsername("root");
  75.         dsc.setPassword("123456");
  76.         mpg.setDataSource(dsc);
  77.         // TODO 包配置,按模板分
  78.         PackageConfig pc = new PackageConfig();
  79.         //pc.setModuleName(scanner("模块名"));
  80.         pc.setParent("com.alibaba.demo");
  81.         pc.setEntity("model");
  82.         pc.setService("service");
  83.         pc.setServiceImpl("service.impl");
  84.         pc.setMapper("dao");
  85.         mpg.setPackageInfo(pc);
  86.         // 自定义配置
  87.         InjectionConfig cfg = new InjectionConfig() {
  88.             @Override
  89.             public void initMap() {
  90.                 // to do nothing
  91.             }
  92.         };
  93.         // 如果模板引擎是 freemarker
  94.         String templatePath = "/templates/mapper.xml.ftl";
  95.         // 自定义输出配置
  96.         List<FileOutConfig> focList = new ArrayList<>();
  97.         // 自定义配置会被优先输出
  98.         focList.add(new FileOutConfig(templatePath) {
  99.             @Override
  100.             public String outputFile(TableInfo tableInfo) {
  101.                 // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
  102.                 return projectPath + "/src/main/resources/mapper/" +
  103.                         tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
  104.             }
  105.         });
  106.         cfg.setFileOutConfigList(focList);
  107.         mpg.setCfg(cfg);
  108.         // 配置模板
  109.         TemplateConfig templateConfig = new TemplateConfig();
  110.         // 配置自定义输出模板
  111.         // 指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
  112.         // templateConfig.setEntity("templates/entity2.java");
  113.         // templateConfig.setService();
  114.         // templateConfig.setController();
  115.         templateConfig.setXml(null);
  116.         mpg.setTemplate(templateConfig);
  117.         // 策略配置，驼峰式
  118.         StrategyConfig strategy = new StrategyConfig();
  119.         strategy.setNaming(NamingStrategy.underline_to_camel);
  120.         strategy.setColumnNaming(NamingStrategy.underline_to_camel);
  121.         strategy.setEntityLombokModel(true);
  122.         strategy.setRestControllerStyle(true);
  123.         // 公共父类,实体继承自通用父类，例如时间等字段可以提取
  124.         // strategy.setSuperControllerClass("com.alibaba.demo.model");
  125.         // 写于父类中的公共字段
  126.         // strategy.setSuperEntityColumns("id");
  127.         strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
  128.         strategy.setControllerMappingHyphenStyle(true);
  129.         strategy.setTablePrefix(pc.getModuleName() + "_");
  130.         mpg.setStrategy(strategy);
  131.         mpg.setTemplateEngine(new FreemarkerTemplateEngine());
  132.         mpg.execute();
  133.     }
  134. }

五、添加测试

测试Mybatis-Plus的CURD等方法。

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class SampleTest {
  4.     private static Logger log = LoggerFactory.getLogger(SampleTest.class);
  5.     @Autowired
  6.     private MpUserService mpUserService;
  7.     @Test
  8.     public void test1() {
  9.         // 插入新记录
  10.         MpUser mpUser = new MpUser();
  11.         //mpUser.setId(1L);
  12.         mpUser.setEmail("test66@baomidou.com");
  13.         mpUser.setAge(22);
  14.         mpUser.setName("David Hong");
  15.         mpUserService.save(mpUser);
  16.         // 或者
  17.         mpUser.insertOrUpdate();
  18.         // 更新完成后，mpUser对象的id会被补全
  19.         log.info("mpUser={}", mpUser.toString());
  20.     }
  21.     @Test
  22.     public void test2() {
  23.         // 通过主键id查询
  24.         MpUser mpUser = mpUserService.getById(1);
  25.         log.info("mpUser={}", mpUser.toString());
  26.     }
  27.     @Test
  28.     public void test3() {
  29.         // 条件查询，下面相当于xml中的 select * from mp_user where name = 'Tom' and age = '28' limit 1
  30.         MpUser mpUser = mpUserService.getOne(new QueryWrapper<MpUser>().eq("name", "Tom").eq("age", "28").last("limit 1"));
  31.         log.info("mpUser={}", mpUser.toString());
  32.         // 批量查询
  33.         List<MpUser> mpUserList = mpUserService.list();
  34.         System.out.println("------------------------------all");
  35.         mpUserList.forEach(System.out::println);
  36.         // 分页查询 
  37.         int pageNum = 1;
  38.         int pageSize = 10;
  39.         IPage<MpUser> mpUserIPage = mpUserService.page(new Page<>(pageNum, pageSize), new QueryWrapper<MpUser>().gt("age", "20"));
  40.         // IPage to List
  41.         List<MpUser> mpUserList1 = mpUserIPage.getRecords();
  42.         System.out.println("------------------------------page");
  43.         mpUserList1.forEach(System.out::println);
  44.         // 总页数
  45.         long allPageNum = mpUserIPage.getPages();
  46.         System.out.println("------------------------------allPageNum");
  47.         System.out.println(allPageNum);
  48.     }
  49.      @Test
  50.     public void test4() {
  51.         MpUser mpUser = mpUserService.getById(2);
  52.         // 修改更新
  53.         mpUser.setName("广东广州");
  54.         //mpUserService.updateById(mpUser);
  55.         // 或者
  56.         mpUser.insertOrUpdate();
  57.         // 通过主键id删除
  58.         mpUserService.removeById(1);
  59.         // 或者
  60.         //mpUser.deleteById();
  61.     }
  62. }

六、数据分页

1、简单分页方法

  1. int pageNum = 1;
  2. int pageSize = 10;
  3. IPage<MpUser> mpUserIPage = mpUserService.page(new Page<>(pageNum, pageSize), new QueryWrapper<MpUser>().gt("age", "20"));

上面的分页其实是调用BaseMapper的selectPage方法，这样的分页返回的数据确实是分页后的数据，但在控制台打印的SQL语句上看到其实并没有真正的物理分页，而是通过缓存来获得全部数据中再进行的分页，这样对于大数据量操作时是不可取的，那么接下来就叙述一下，真正实现物理分页的方法。

2、 物理分页方法

新建一个MybatisPlusConfig配置类文件

  1. //Spring boot方式
  2. @EnableTransactionManagement
  3. @Configuration
  4. @MapperScan("com.baomidou.cloud.service.*.mapper*")
  5. public class MybatisPlusConfig {
  6.     @Bean
  7.     public PaginationInterceptor paginationInterceptor() {
  8.         PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
  9.         // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
  10.         // paginationInterceptor.setOverflow(false);
  11.         // 设置最大单页限制数量，默认 500 条，-1 不受限制
  12.         // paginationInterceptor.setLimit(500);
  13.         // 设置数据源为mysql,数据源配置使用阿里TDDL或其他数据源时，需要自行设置
  14.         paginationInterceptor.setDbType(DbType.MYSQL);
  15.         return paginationInterceptor;
  16.     }
  17. }

重新调用mpUserService.page可以看到数据有物理分页

3、XML自定义分页

  • UserMapper.java 方法内容
  1. public interface UserMapper{//可以继承或者不继承BaseMapper
  2.     /**
  3.      * <p>
  4.      * 查询 : 根据state状态查询用户列表，分页显示
  5.      * 注意!!: 如果入参是有多个,需要加注解指定参数名才能在xml中取值
  6.      * </p>
  7.      *
  8.      * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象)
  9.      * @param state 状态
  10.      * @return 分页对象
  11.      */
  12.     IPage<User> selectPageVo(Page page, @Param("age") Integer age);
  13. }
  • UserMapper.xml 等同于编写一个普通 list 查询，mybatis-plus 自动替你分页
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="cn.com.bluemoon.demo.mapper.MpUserMapper">
  4.     <select id="selectPageVo" resultType="cn.com.bluemoon.demo.entity.MpUser">
  5.       SELECT * FROM mp_user WHERE age=#{age}
  6.     </select>
  7. </mapper>
  • UserServiceImpl.java 调用分页方法
  1. public IPage<User> selectUserPage(Page<User> page, Integer state) {
  2.     // 不进行 count sql 优化，解决 MP 无法自动优化 SQL 问题，这时候你需要自己查询 count 部分
  3.     // page.setOptimizeCountSql(false);
  4.     // 当 total 为小于 0 或者设置 setSearchCount(false) 分页插件不会进行 count 查询
  5.     // 要点!! 分页返回的对象与传入的对象是同一个
  6.     return baseMapper.selectPageVo(page, state);
  7. }

4、测试自定义方法

  1. @Test
  2.     public void test5() {
  3.         Page<MpUser> mpUserPage = new Page<>(1,2);
  4.         IPage<MpUser> iPage = mpUserService.selectUserPage(mpUserPage,22);
  5.         System.out.println("总页数："+iPage.getPages());
  6.         System.out.println("总记录数："+iPage.getTotal());
  7.         List<MpUser> mpUserList1 = iPage.getRecords();
  8.         mpUserList1.forEach(System.out::println);
  9.     }

七、打印sql日志

为了方便排查错误，很多时候需要打印mybatis生成的sql语句，这时候就需要打印日志了。
在application.yml中添加：

  1. # Logger Config
  2. logging:
  3.   level:
  4.     cn.com.vicente.demo: debug

或者

  1. mybatis-plus:
  2.   configuration:
  3.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

八、逻辑删除

很多时候需要表的数据虽然删除了，但是还是希望不是真正删除数据，数据还是留在数据库中，只需要使用一个字段来做标志为即可，这时候就需要逻辑删除功能。
SpringBoot 配置方式：

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

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

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

    1. import com.baomidou.mybatisplus.core.injector.ISqlInjector;
    2. import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. @Configuration
    6. public class MyBatisPlusConfiguration {
    7.   @Bean
    8.   public ISqlInjector sqlInjector() {
    9.       return new LogicSqlInjector();
    10.   }
    11. }

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

  • @TableField(select = false)注解，可以不查询出deleted字段

    1. @TableLogic
    2. //@TableField(select = false)
    3. private Integer deleted;

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

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

    附件说明

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

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

    九、主键策略

    mybatis-plus 的主键生成的类型 默认类型 是 IdType.ID_WORKER全局唯一ID，内容为空自动填充（默认配置），雪花算法
    1，局部主键策略实现
    在实体类中 ID属性加注解
  1. @TableId(type = IdType.AUTO) 主键自增 数据库中需要设置主键自增
  2. private Long id;
  3. @TableId(type = IdType.NONE) 默认跟随全局策略走
  4. private Long id;
  5. @TableId(type = IdType.UUID) UUID类型主键
  6. private Long id;
  7. @TableId(type = IdType.ID_WORKER) 数值类型数据库中也必须是数值类型 否则会报错
  8. private Long id;
  9. @TableId(type = IdType.ID_WORKER_STR) 字符串类型   数据库也要保证一样字符类型
  10. private Long id;
  11. @TableId(type = IdType.INPUT) 用户自定义了  数据类型和数据库保持一致就行
  12. private Long id;

2，全局主键策略实现
需要在application.yml文件中添加

  1. mybatis-plus:
  2.   global-config:
  3.     db-config:
  4.       id-type: uuid/none/input/id_worker/id_worker_str/auto   表示全局主键都采用该策略（如果全局策略和局部策略都有设置，局部策略优先级高）

十、自动填充

很多时候表中都需要添加创建时间，创建人，修改时间，修改人来跟踪数据的来源和变动，但每次插入数据和修改数据的时候都要set这几个字段又感觉很麻烦，这个时候就系统系统能自动填充这几个字段了。

  • 注意：自动填充字段类型在拦截器中类型需要一致

  1. 字段必须声明TableField注解，属性fill选择对应策略，该申明告知 Mybatis-Plus 需要预留注入 SQL 字段

    1.  @TableField(fill = FieldFill.INSERT)
    2.  private LocalDateTime createTime;
    3.  @TableField(fill = FieldFill.INSERT_UPDATE)
    4.  private LocalDateTime updateTime;

  2. 属性fill有四种对应策略，分别为：

    1. public enum FieldFill {
    2.  /**
    3.   * 默认不处理
    4.   */
    5.  DEFAULT,
    6.  /**
    7.   * 插入填充字段
    8.   */
    9.  INSERT,
    10.  /**
    11.   * 更新填充字段
    12.   */
    13.  UPDATE,
    14.  /**
    15.   * 插入和更新填充字段
    16.   */
    17.  INSERT_UPDATE
    18. }

  3. 自定义实现类 MyMetaObjectHandler:

    1. @Component
    2. public class MyMetaObjectHandler implements MetaObjectHandler {
    3.  private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);
    4.  @Override
    5.  public void insertFill(MetaObject metaObject) {
    6.      LOGGER.info("start insert fill ....");
    7.      //this.setFieldValByName("createTime", LocalDateTime.now(), metaObject);
    8.      this.setInsertFieldValByName("createTime", LocalDate.now(), metaObject);
    9.      this.setInsertFieldValByName("updateTime", LocalDate.now(), metaObject);
    10.  }
    11.  @Override
    12.  public void updateFill(MetaObject metaObject) {
    13.      LOGGER.info("start update fill ....");
    14.      this.setUpdateFieldValByName("updateTime", LocalDate.now(), metaObject);
    15.  }
    16. }

  4. 测试使用

    1. @Test
    2.  public void testInsert() {
    3.      // 插入新记录
    4.      MpUser mpUser = new MpUser();
    5.      mpUser.setEmail("wm@baomidou.com");
    6.      mpUser.setAge(28);
    7.      mpUser.setName("王蒙");
    8.      mpUserService.save(mpUser);
    9.      log.info("mpUser={}", mpUser.toString());
    10.  }
    11. @Test
    12.  public void testUpdate() {
    13.      // 更新记录
    14.      MpUser mpUser = new MpUser();
    15.      mpUser.setId(1182478087497998337L);
    16.      MpUser newUser = mpUser.selectById();
    17.      System.out.println(mpUser == newUser);
    18.      mpUser.setName("王天");
    19.      mpUser.updateById();
    20.      log.info("mpUser={}", mpUser.toString());
    21.      log.info("newUser={}", newUser.toString());
    22.  }

  5. 自动填充优化
    insertFill方法每次插入的时候都会调用，如果不存在createTime属性的话，每次插入都会白白调用了，浪费资源，所以可以判断是否存在该属性

    1. boolean hasCreateTime = metaObject.hasSetter("createTime");
    2.      if (hasCreateTime){
    3.          this.setInsertFieldValByName("createTime", LocalDateTime.now(), metaObject);
    4.      }

    希望，当更新时有设定时间，就用更新时设定的时间，当没有设定时就自动填充更新时间，可以这样设置

  1. Object fieldValue = getFieldValByName("updateTime", metaObject);
  2.         if (fieldValue == null){
  3.             this.setUpdateFieldValByName("updateTime", LocalDateTime.now(), metaObject);/
  4.         }

十一、 druid 查看sql执行情况

localhost:port/druid

十二、map自定义驼峰转化

  1. // 配置类注入bean   
  2. @Bean
  3.     public ConfigurationCustomizer mybatisConfigurationCustomizer(){
  4.         return configuration -> configuration.setObjectWrapperFactory(new MybatisMapWrapperFactory());
  5.     }

十三、Mybatis-plus多租户应用及避开方式(3.4.1之前版本)

  • 后续mybatisplus版本默认支持租户隔离，参考官方文档 https://baomidou.com/pages/2976a3/#innerinterceptor

    1、配置类

    ```java import com.baomidou.mybatisplus.core.parser.ISqlParser; import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor; import com.baomidou.mybatisplus.extension.plugins.tenant.TenantHandler; import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.StringValue; import org.mybatis.spring.annotation.MapperScan; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

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

@Configuration @MapperScan(“com.demo.*.mapper”) public class MyBatisPlusConfig {

  1. @Bean
  2. public PaginationInterceptor paginationInterceptor() {
  3.     PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
  5.     // 创建SQL解析器集合
  6.     List<ISqlParser> sqlParserList = new ArrayList<>();
  8.     // 创建租户SQL解析器
  9.     TenantSqlParser tenantSqlParser = new TenantSqlParser();
  11.     // 设置租户处理器
  12.     tenantSqlParser.setTenantHandler(new TenantHandler() {
  13.         @Override
  14.         public Expression getTenantId(boolean where) {
  15.             // 设置当前租户标识
  16.             return new StringValue(TenantContext.getTenant());//从当前线程中拿租户标识
  17.         }
  19.         @Override
  20.         public String getTenantIdColumn() {
  21.             // 对应数据库租户标识的列名
  22.             return "tenant_id";
  23.         }
  25.         @Override
  26.         public boolean doTableFilter(String tableName) {
  27.             // 过滤哪些表
  28.             List<String> tableNameList = Arrays.asList("user");
  29.             if (tableNameList.contains(tableName)){
  30.                 return true;
  31.             }
  32.             return false;
  33.         }
  34.     });
  35.     sqlParserList.add(tenantSqlParser);
  36.     paginationInterceptor.setSqlParserList(sqlParserList);
  38.     //需要过滤某一个方法
  39.     paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
  40.         @Override
  41.         public boolean doFilter(MetaObject metaObject) {
  42.             MappedStatement ms = SqlParserHelper.getMappedStatement(metaObject);
  43.             // 对应Mapper、dao中的方法
  44.             if("com.demo.mybatis.mapper.MyMapper.getOne".equals(ms.getId())){
  45.                 return true;
  46.             }
  47.             return false;
  48.         }
  49.     });        
  50.     return paginationInterceptor;
  51. }

}

  1. 实现效果：针对没有被过滤的表和方法，SQL后面会增加条件 tenant_id="租户标识"
  2. <a name="BIfPZ"></a>
  3. #### 2、租户获取
  4. ```java
  5. public class TenantContext {
  6.     private static ThreadLocal<String> currentTenant = new ThreadLocal();
  8.     public TenantContext() {
  9.     }
  11.     //在登录的时候向当前线程中存放租户标识
  12.     public static void setTenant(String tenant) {
  13.         currentTenant.set(tenant);
  14.     }
  16.     //需要的时候，从当前线程取租户标识
  17.     public static String getTenant() {
  18.         return (String)currentTenant.get();
  19.     }
  21.     public static void clear() {
  22.         currentTenant.remove();
  23.     }
  24. }

作用：用于更改当前线程的租户标识，避开租户隔离等

3、忽略租户的方式

  • 方法一：查询数据库前设置租户标识

    1. TenantContext.setTenant("租户标识")

  • 方法二：在MybatisPlusConfig的paginationInterceptor()方法的doTableFilter中设置需要过滤的表名

    1. @Override
    2. public boolean doTableFilter(String tableName) {
    3.   // 过滤哪些表
    4.   List<String> tableNameList = Arrays.asList("user");
    5.   if (tableNameList.contains(tableName)){
    6.       return true;
    7.   }
    8.   return false;
    9. }

  • 方法三：在MybatisPlusConfig的paginationInterceptor()方法中设置setSqlParserFilter,过滤方法

    1. //需要过滤某一个方法
    2. paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
    3.   @Override
    4.   public boolean doFilter(MetaObject metaObject) {
    5.       MappedStatement ms = SqlParserHelper.getMappedStatement(metaObject);
    6.       // 对应Mapper、dao中的方法
    7.       if("com.demo.mybatis.mapper.MyMapper.getOne".equals(ms.getId())){
    8.           return true;
    9.       }
    10.       return false;
    11.   }
    12. });