MybatisPlus学习笔记

MybatisPlus

此博客为个人学习笔记，使用的版本为3.0.5，与最新版本有一定的出入，建议以官网文档为主
https://baomidou.com/guide/

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 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速开始

1. 新建项目、建库、建表

   DROP TABLE IF EXISTS user;
   
   CREATE TABLE user
   (
   	id BIGINT(20) NOT NULL COMMENT '主键ID',
   	name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
   	age INT(11) NULL DEFAULT NULL COMMENT '年龄',
   	email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
   	PRIMARY KEY (id)
   );
   
   DELETE FROM user;
   
   INSERT INTO user (id, name, age, email) VALUES
   (1, 'Jone', 18, '[e-mail]'),
   (2, 'Jack', 20, '[e-mail]'),
   (3, 'Tom', 28, '[e-mail]'),
   (4, 'Sandy', 21, '[e-mail]'),
   (5, 'Billie', 24, '[e-mail]');
   

2. 导入依赖

   <!--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>
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.47</version>
   </dependency>
   

3. 配置文件

   spring:
     datasource:
       url: jdbc:mysql://47.99.74.215:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
       driver-class-name: com.mysql.jdbc.Driver
       username: root
       password: root
   

4. 实体类（快速创建），后面才知道MP有自带的快速生成插件…，看个热闹吧

选择实体类要存放的包即可

默认创建的实体类不太能满足我们的要求：包路径错误、没有使用lombok

改一下他的代码就行了

打开这个文件

加几行代码

import com.intellij.database.model.DasTable
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

/*
 * Available context bindings:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */

packageName = "com.sample;"
typeMapping = [
  (~/(?i)int/)                      : "Long",
  (~/(?i)float|double|decimal|real/): "Double",
  (~/(?i)datetime|timestamp/)       : "java.sql.Timestamp",
  (~/(?i)date/)                     : "java.sql.Date",
  (~/(?i)time/)                     : "java.sql.Time",
  (~/(?i)/)                         : "String"
]

FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
  SELECTION.filter { it instanceof DasTable }.each { generate(it, dir) }
}

def generate(table, dir) {
  def className = javaName(table.getName(), true)
  def fields = calcFields(table)
  packageName = getPackageName(dir)
  new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields) }
}

def generate(out, className, fields) {
  out.println "package $packageName"
  out.println ""
  out.println "import lombok.Data;"
  out.println "import java.io.Serializable;"
  out.println "@Data"
  out.println "public class $className implements Serializable {"
  out.println ""
  fields.each() {
    if (it.annos != "") out.println "  ${it.annos}"
    out.println "  private ${it.type} ${it.name};"
  }
  out.println ""

  out.println "}"
}

// 获取包所在文件夹路径
def getPackageName(dir) {
    return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
}

def calcFields(table) {
  DasUtil.getColumns(table).reduce([]) { fields, col ->
    def spec = Case.LOWER.apply(col.getDataType().getSpecification())
    def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
    fields += [[
                 name : javaName(col.getName(), false),
                 type : typeStr,
                 annos: ""]]
  }
}

def javaName(str, capitalize) {
  def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
    .collect { Case.LOWER.apply(it).capitalize() }
    .join("")
    .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
  capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

最后生成的样子

5. 创建 Mapper

   @Mapper
   public interface UserMapper extends BaseMapper<User> {
   }
   

   @MapperScan("com.zjgsu.demo.mapper")
   @SpringBootApplication
   public class MybatisPlusApplication {
   

6. 测试

   @SpringBootTest
   class MybatisPlusApplicationTests {
   
       @Autowired
       private UserMapper userMapper;
   
       @Test
       void contextLoads() {
           List<User> users = userMapper.selectList(null);  //查询条件为空，表示全部查询
           users.forEach(System.out::println);
       }
   }
   

配置日志

# 日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

CRUD

Insert操作

@Test
public void testInsert() {
    User user = new User();
    user.setAge(3L);
    user.setEmail("[e-mail]");
    user.setName("不知道");
    int result = userMapper.insert(user);
    System.out.println(result);
    System.out.println(user);
}

主键生成策略

自增长

首先要确保数据库里配置了主键自增长

然后再在这个基础上添加注解

@TableId(type = IdType.AUTO)
private Long id;

其他策略

public enum IdType {
    AUTO(0),  //自增长
    NONE(1),  //无主键
    INPUT(2),  //手动输入
    ID_WORKER(3),  //默认，全局唯一id，雪花算法
    UUID(4),  //全局唯一id，uuid
    ID_WORKER_STR(5);  //字符串表示的ID_WORKER

    private int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

INPUT

ID_WORKER_STR

类型冲突…

Update操作

@Test
public void testUpdate() {
    User user = new User();
    user.setId(1L);
    user.setAge(3L);
    userMapper.updateById(user);
}

自动填充

自动生成创建时间和修改时间

• 添加注解

@TableField(fill = FieldFill.INSERT)
private Date createTime;

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

• 自定义 MetaObjectHandler

@Component
@Slf4j
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

• 测试添加

• 测试修改

乐观锁

乐观锁实现方式

1. 取出数据时，获取当前version
2. 对数据进行操作时，带上这个version
3. 执行操作时，判断version与现在的version是否相同
4. 如果不同，表示之前读出的数据被动过了，更新失败
5. 如果相同，则继续更新，并且version = version + 1

乐观锁插件

1. 给表加上version字段
2. 实体类添加属性，并加上注解

@Version
private Integer version;

3. 注册组件

@Configuration
public class MybatisPlusConfig {

    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

4. 测试成功案例

@Test
public void testOptimisticLocker() {
    User user = userMapper.selectById(1L);
    user.setName("zty");
    userMapper.updateById(user);
}

5. 测试失败案例

@Test
public void testOptimisticLocker2() {
    User user = userMapper.selectById(1L);
    user.setName("zty");

    //模拟插队线程
    User user2 = userMapper.selectById(1L);
    user2.setName("zty111");
    userMapper.updateById(user2);

    userMapper.updateById(user);
}

Select操作

基本查询

//根据id查询
@Test
public void testSelectById() {
    User user = userMapper.selectById(2L);
    System.out.println(user);
}

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

//测试条件查询
@Test
public void testSelectByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("age", 24);
    map.put("id", 4);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

查询分页

注册组件 PaginationInterceptor

@Bean
public PaginationInterceptor paginationInnerInterceptor() {
    return new PaginationInterceptor();
}

使用分页插件

@Test
public void testPage() {
    Page<User> page = new Page<>(1, 5);  //第1页，每页5条记录
    IPage<User> userIPage = userMapper.selectPage(page, null);
    System.out.println(userIPage  == page);  //page和IPage是同一个对象
    System.out.println(page.getRecords());  //查询结果
    System.out.println(page.getCurrent());  //当前页数
    System.out.println(page.getSize());  //每页记录数
    System.out.println(page.getTotal());  //总记录数
    System.out.println(page.getPages());  //总页数
}

删除操作

基本的删除就不写了，看方法名字就知道是干嘛的

逻辑删除

执行删除操作时并不是真的将数据从数据库中删除，而是修改一个字段，比如 deleted

这样管理员就可以看到被“删除的数据”，相当于回收站

使用方法

1. 给实体类字段加上 @TableLogic 注解

@TableLogic
private Integer deleted;

2. 修改配置文件

mybatis-plus:
	global-config:
    	db-config:
     	 	logic-delete-value: 1  # 删除的记录为1
      		logic-not-delete-value: 0  # 没删除的记录为0

3. 注册组件（新版本不用了）

@Bean
public ISqlInjector sqlInjector() {
    return new LogicSqlInjector();
}

测试

@Test
public void testLogicDelete() {
    userMapper.deleteById(1L);
}

可以看到 delete 操作变成了 update 操作

之后的 select 操作都会带上 deleted = 0 的条件

性能分析插件

注册组件

@Bean
@Profile({"dev", "test"})  //dev test环境下开启该插件
public PerformanceInterceptor performanceInterceptor() {
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(1);  //设置sql执行时间上限 毫秒
    performanceInterceptor.setFormat(true);  //开启sql格式化
    return performanceInterceptor;
}

把时间设置为 1ms ，执行sql试一试

条件构造器

这个很重要，但是真的没什么可写的，和以前用的 Mybatis-Generator 很像

@Test
public void testWrapper() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.like("name", "a").likeRight("name", "S");  //模糊查询
    User user = userMapper.selectOne(wrapper);
    System.out.println(user);
}

顺便注意一下，如果用 selectOne 返回的数据多余1条会抛出异常

代码生成器

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

导入依赖

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

代码

直接贴代码吧，不过就是对官网的代码改了一点点罢了

public class MybatisGenerator {

    /**
     * <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 (ipt != null && !ipt.trim().isEmpty()) {
                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.setOpen(false);
        gc.setSwagger2(true);  //自带swagger注解
        gc.setAuthor("zty");
        gc.setFileOverride(true);  //覆盖原文件
        mpg.setGlobalConfig(gc);

        //数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUrl("jdbc:mysql://localhost:3306/market?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);

        // 包配置，生成的entity、controller等都放在这个包下
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("demo");
        pc.setParent("com.zjgsu");
        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出Mapper文件名
                return projectPath + "/src/main/resources/mapper/" +
                        tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        templateConfig.setXml(null);  //不在java包下创建xml文件
        mpg.setTemplate(templateConfig);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);  //Lombok
        strategy.setRestControllerStyle(true);
        //下面这行注释掉的话就会给所有表生成
        //strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));  //要映射的表名
        strategy.setControllerMappingHyphenStyle(true);

        //自动填充
        TableFill create_time = new TableFill("create_time", FieldFill.INSERT);
        TableFill update_time = new TableFill("update_time", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(create_time);
        tableFills.add(update_time);
        strategy.setTableFillList(tableFills);
        //逻辑删除
        strategy.setLogicDeleteFieldName("deleted");
        //乐观锁
        strategy.setVersionFieldName("version");

        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());

        mpg.execute();

    }
}

突然发现 mybatis.mapper-locations 其实可以不配

只要有 @MapperScan 注解扫描就可以使 Mapper 生效

使用Logback

感觉还是 Logback 用的习惯一点

1. 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

2. logback-spring.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!--debug为true时会打印logback的内部信息-->
<configuration debug="false" scan="true">

    <!-- 日志级别 -->
    <springProperty scope="context" name="LOG_ROOT_LEVEL" source="logging.level.root" defaultValue="info"/>
    <!--  标识这个"STDOUT" 将会添加到这个logger -->
    <springProperty scope="context" name="STDOUT" source="log.stdout" defaultValue="STDOUT"/>

    <!-- 日志格式，%d：日期；%thread：线程名；%-5level：日志级别从左显示5个字符长度，列如:DEBUG；
        %logger{36}：java类名，例如:com.muses.taoshop.MyTest，36表示字符长度；%msg：日志内容；%d：换行 -->
    <property name="LOG_PATTERN" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
    <!-- root日志级别-->
    <property name="${LOG_ROOT_LEVEL}" value="info" />
    <!-- 日志跟目录 -->
    <property name="LOG_HOME" value="/log/logs" />
    <!-- 日志文件路径-->
    <property name="LOG_DIR" value="${LOG_HOME}/%d{yyyyMMdd}" />
    <!-- 日志文件名称 -->
    <property name="LOG_PREFIX" value="portal" />
    <!-- 日志文件编码 -->
    <property name="LOG_CHARSET" value="utf-8" />
    <!-- 配置日志的滚动时间，保存时间为15天-->
    <property name="MAX_HISTORY" value="15" />
    <!-- 文件大小，默认为10MB-->
    <property name="MAX_FILE_SIZE" value="10MB" />


    <!-- ConsoleAppender 打印到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 格式化日志内容-->
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>


    <!-- 打印所有日志，保存到文件-->
    <appender name="FILE_ALL" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--文件名  data/logs/all_portal.log-->
        <file>${LOG_HOME}/all_${LOG_PREFIX}.log</file>

        <!-- 设置滚动策略，当日志文件大小超过${MAX_FILE_SIZE}时，新的日志内容写到新的日志文件-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 新的日志文件路径名称，%d:日期 %i:i是变量 -->
            <!--all_portal2020-10-10.86.log-->
            <fileNamePattern>${LOG_DIR}/all_${LOG_PREFIX}%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 保存日志15天 -->
            <maxHistory>${MAX_HISTORY}</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- 日志文件的最大大小 -->
                <maxFileSize>${MAX_FILE_SIZE}</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>

        <!-- 格式日志文件内容-->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>${LOG_PATTERN}</pattern>
        </layout>
    </appender>

    <!--要打印sql语句-->
    <!--这里的配置写在yml文件中也同样生效-->
<!--    <logger name="com.zjgsu.demo.mapper" level="DEBUG" />-->
<!--    <logger name="org.mybatis" level="DEBUG" />-->

    <!-- 日志输出级别 -->
    <root leve="${LOG_ROOT_LEVEL}">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE_ALL" />
    </root>

</configuration>

之前一直是在 <logger> 标签中配置包名和对应的日志等级，这次发现在 yml 配置也是同样的效果

3. 配置文件

logging:
  config: classpath:logback-spring.xml
  level:
    root: info
    com.zjgsu.demo.mapper: debug

4. 测试

成功咯