[Java知识库]MyBatis-Plus 的详细使用

一，简介

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

愿景

我们的愿景是成为 MyBatis 最好的搭档，就像?魂斗罗?中的 1P、2P，基友搭配，效率翻倍。

?

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

支持数据库

任何能使用 MyBatis 进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，
如果不在下列表查看分页部分教程 PR 您的支持。

MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，
Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb

达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，
神通数据库，瀚高数据库

框架结构

?

二，使用

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

2，创建springboot工程，加入必要的依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

3，编写项目配置文件，项目名称，数据库配置

server:
  port: 8080
spring:
  application:
    name: mybatis-plus
  datasource:
    url: jdbc:mysql://www.xlz.com/mybatis-plus?useEncoding=utf8mb4&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

1，生成实体类

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

2，编写 mapper 继承?BaseMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zking.mpdemo.model.User;
import org.springframework.stereotype.Repository;
@Repository
public interface UserMapper extends BaseMapper<User> {
}

3，启动类，指定mapper接口的位置

@MapperScan("com.zking.mpdemo.**")

4，测试

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

以上的操作还略显麻烦? 代码生成器来帮你！

三，代码生成器

package com.lgs.code.generator;
 
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.baomidou.mybatisplus.generator.fill.Column;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
@Slf4j
public class MysqlGenerator {
    protected static String URL = "jdbc:mysql://www.xlz.com/mybatis-plus?useEncoding=utf8mb4&serverTimezone=Asia/Shanghai&useSSL=false";
    protected static String USERNAME = "root";
    protected static String PASSWORD = "123456";
 
    protected static DataSourceConfig.Builder DATA_SOURCE_CONFIG = new DataSourceConfig.Builder(URL, USERNAME, PASSWORD);
 
    public static void main(String[] args) {
        FastAutoGenerator.create(DATA_SOURCE_CONFIG)
                .globalConfig(
                        (scanner/*lamdba*/, builder/*变量*/) ->
                                builder.author(scanner.apply("请输入作者名称？"))
                                        .enableSwagger()
                                        .fileOverride()
                                        .outputDir(System.getProperty("user.dir") + "\\src\\main\\java")
                                        .commentDate("yyyy-MM-dd")
                                        .dateType(DateType.TIME_PACK)
                )
                .packageConfig((builder) ->
                        builder.parent("com.lgs.code")
                                .entity("pojo")
                                .service("service")
                                .serviceImpl("service.impl")
                                .mapper("mapper")
                                .xml("mapper.xml")
                                .pathInfo(Collections.singletonMap(OutputFile.xml, System.getProperty("user.dir") + "\\src\\main\\resources\\mapper"))
                )
                .injectionConfig((builder) ->
                        builder.beforeOutputFile(
                                (a, b) -> log.warn("tableInfo: " + a.getEntityName())
                        )
                )
                .strategyConfig((scanner, builder) ->
                        builder.addInclude(getTables(scanner.apply("请输入表名，多个英文逗号分隔？所有输入 all")))
                                .addTablePrefix("tb_")
                                .entityBuilder()
                                .enableChainModel()
                                .enableLombok()
                                .enableTableFieldAnnotation()
                                .addTableFills(
                                        new Column("create_time", FieldFill.INSERT)
                                )
                                .controllerBuilder()
                                .enableRestStyle()
                                .enableHyphenStyle()
                                .build())
                .templateEngine(new FreemarkerTemplateEngine())
                .execute();
    }
 
    protected static List<String> getTables(String tables) {
        return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));
    }
 
 
 
}

?

四，日志

日志主要体现在当运行程序的时候，将会在控制台将会打印日志信息

使用在?application.xml 文件中加入

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

五，主键生成策略

1，雪花算法

默认的主键生策略，如果需要保存的实体对象中没有指定的主键值，则默认使用雪花算法来生成

2，自增ID

1、数据库的字段必须是配置了自增、

2、对应的实体的主键字段加入自增注解： @TableId(type = IdType.AUTO)

3，其他类型

package com.baomidou.mybatisplus.annotation;

public enum IdType {
    AUTO(0),
    NONE(1),
    INPUT(2),
    ASSIGN_ID(3),
    ASSIGN_UUID(4);

    private final int key;

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

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

主键生成策略所生成的主键ID都是唯一的

六，更新

package com.example.mybatisplus;
 
import com.example.mybatisplus.mapper.TUserMapper;
import com.example.mybatisplus.mapper.UserMapper;
import com.example.mybatisplus.pojo.TUser;
import com.example.mybatisplus.service.ITUserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
import java.util.UUID;
 
@SpringBootTest
class MybatisPlusApplicationTests {
 
 
    @Autowired
    private TUserMapper mapper;
 
    @Autowired
    private ITUserService service;
    @Test
    void contextLoads() {
        TUser user = new TUser().setId(1L).setAccount("aaaa");
        int u = mapper.updateById(user);
        System.out.println(u);
 
    }
 
}

七，自动填充

在数据表的设计中，经常需要加一些字段，

如：创建时间，最后修改时间等，此时可以使用mybatisplus来帮我们进行自动维护

在自动填充有两种方式：

一，通过数据库完成自动填充

@Data
public class User {
@TableId(type = IdType.AUTO)
private int id;
private String name;
private Integer age;
private String email;
//在代码中同步加入创建时间和最后修改时间的维护
private Date createTime;
private Date lastModifiedTime;
}

完成后可以通过新增或更新

二，使用程序完成自动填充 将数据库中的自动维护功能取消：

第一步，实体类中加入注解

//表明在插入时自动维护字段
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//表明在插入和更新时自动维护字段
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date lastModifiedTime;

第二步，编写处理类

// 不要忘了处理器是spring的组件
@Component
public class AutoFillHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
this.setFieldValByName("createTime",new Date(), metaObject);
this.setFieldValByName("lastModifiedTime",new Date(), metaObject);
}
@Override
public void updateFill(MetaObject metaObject) {
//this.setFieldValByName("createTime",new Date(), metaObject);
this.setFieldValByName("lastModifiedTime",new Date(), metaObject);
}
}

完成后可以通过新增或更新

八，乐观锁

当要更新一条记录的时候，希望这条记录没有被别人更新

乐观锁实现方式（来自官方文档）：

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

配置示例：

1，在数据库表中加入version字段，表示数据版本号??修改实体类，在使用类中加入对应的version字段，并使用是乐观锁

//乐观锁
@Version
private int version;

1，配置乐观锁

@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return interceptor;
}
}

1，测试

//测试乐观锁
@Test
public void testLock01() {
User user01 = userMapper.selectById(7L);
User user02 = userMapper.selectById(7L);
user01.setName("leguansuo01");
userMapper.updateById(user01);
user02.setName("leguansuo02");
userMapper.updateById(user02);
}

九，条件查询

批量查询多个对象

@Test
public void testSelectList() {
//一次查询多个ID
List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
users.forEach(t -> {
System.out.println(t);
});
}
@Test
public void testSelectByMap() {
//使用map进行查询
Map<String, Object> map = new HashMap<>();
map.put("name", "Tom");
map.put("age", 28);
List<User> users = userMapper.selectByMap(map);
users.forEach(t-> System.out.println(t));
}

十，分页

1，分页配置

package com.example.mybatisplus.config;
 
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

2，测试

package com.example.mybatisplus;
 
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.mybatisplus.mapper.TUserMapper;
import com.example.mybatisplus.mapper.UserMapper;
import com.example.mybatisplus.pojo.TUser;
import com.example.mybatisplus.service.ITUserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.UUID;
 
@SpringBootTest
class MybatisPlusApplicationTests {
 
 
    @Autowired
    private TUserMapper mapper;
 
    @Autowired
    private ITUserService service;
    @Test
    void contextLoads() {
        mapper.selectPage(Page.of(1L,2L),null)
        .getRecords()
                .forEach(System.out::println);
    }
 
}

十一，逻辑删除

物理删除使用起来比较简单，仿照查询功能即可，不再赘述。

什么是逻辑删除？ 即：标记删除，并不是真的从数据库中删除，而是做个删除标记，在查询时，过滤掉标记为删除的记录即可。

1，修改实体类

@TableLogic
private int deleted;

2，在application.properties （或application.yml）中加入如下配置

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted
      logic-delete-value: 1
      logic-not-delete-value: 0

3，测试

mapper.deleteById(1L);

十二，Wrapper

package com.example.mybatisplus;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.mybatisplus.mapper.TUserMapper;
import com.example.mybatisplus.mapper.UserMapper;
import com.example.mybatisplus.pojo.TUser;
import com.example.mybatisplus.service.ITUserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
 
@SpringBootTest
class MybatisPlusApplicationTests {
 
 
    @Autowired
    private TUserMapper mapper;
 
    @Autowired
    private ITUserService service;
    @Test
    void contextLoads() {
        QueryWrapper<TUser> wrapper = new QueryWrapper<>();
        wrapper.likeRight("account", "d")
                .eq("password", 1);
        List<TUser> users = mapper.selectList(wrapper);
        users.forEach(t-> System.out.println(t));
 
    }
}

十三，在Mybatis-plus中使用xml配置

mybatis-plus是mybatis的升级版，所以在mybatis-plus中使用xml的配置比较简单

1，在application.properties配置文件中加入如下配置

mybatis-plus.mapper-locations=classpath:/mapper/**/*.xml

2，定义mapper接口，继承BaseMapper接口，以便于使用mybatis-plus提供的方法

@Repository
public interface UserMapperXml extends BaseMapper<User> {
List<User> list();
}

3，根据接口生成xml配置文件，IDE一般有辅助的插件，例如IDEA中的Free Mybatis plugin

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zking.mpdemo.mapper.UserMapperXml">
<select id="list" resultType="com.zking.mpdemo.model.User">
select * from user;
</select>
</mapper>

4，也可以不使用xml配置文件，使用注解来定义sql语句

public interface UserMapperXml extends BaseMapper<User> {
@Select("select * from user")
List<User> list();
}

5，测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = MpdemoApplication.class)
public class UserMapperXmlTest {
@Autowired
private UserMapperXml userMapperXml;
//使用xml配置的方法
@Test
public void list() {
List<User> list = userMapperXml.list();
list.forEach(t-> System.out.println(t));
}
//mybatis-plus提供的方法
@Test
public void testSelectByID() {
User user = userMapperXml.selectById(2L);
System.out.println(user);
}
}

OK！到这就结束了，希望能帮到你！！！