MyBatis Plus教程：快速入门与实战技巧

概述

MyBatis Plus教程详细介绍了一个强大的MyBatis增强工具，提供了简洁的CRUD操作、条件构造器、自定义SQL执行等功能，简化了数据库操作。此外，该教程还涵盖了MyBatis Plus的环境搭建、基本操作、高级功能及与Spring Boot的集成等内容。

MyBatis Plus简介 MyBatis Plus是什么

MyBatis Plus 是一个 MyBatis 的增强工具，旨在简化并增强 MyBatis 的操作。它提供了一系列开箱即用的功能，如条件构造器、自定义SQL执行、分页查询等，大大简化了开发工作。MyBatis Plus 基于 MyBatis 3.x 版本开发，设计目标是成为通用、高性能的 MyBatis 扩展插件。

MyBatis Plus与MyBatis的关系

MyBatis Plus 基于 MyBatis 开发，是 MyBatis 的一个增强工具。它提供了许多便捷的功能和库，以便在项目中更方便地使用 MyBatis。MyBatis Plus 并不是要取代 MyBatis，而是作为 MyBatis 的扩展，为开发者提供更高效、更便捷的数据库操作方式。例如，MyBatis Plus 提供了自动填充、逻辑删除、条件构建等高级功能，都是 MyBatis 原始功能的增强。

MyBatis Plus的主要特点

1. 简洁的CRUD操作：MyBatis Plus 提供了一套开箱即用的CRUD操作，极大地简化了开发流程。
2. 条件构造器：内置了强大的条件构造器，支持链式调用，可以方便地构建复杂的查询条件。
3. 自定义SQL执行：允许自定义SQL执行，满足更复杂的数据操作需求。
4. 逻辑删除：支持逻辑删除功能，可以避免直接物理删除数据带来的风险。
5. 自动填充：支持数据的自动填充功能，可以方便地在插入或更新数据时填充一些特定的字段。
6. 分页插件：提供了一套分页插件，支持多种分页方式，例如通过Page对象实现分页查询。
7. 代码生成器：提供了代码生成器，可以自动生成实体类、Mapper接口和Mapper XML文件。

MyBatis Plus的适用场景

• 简化开发：适用于需要快速开发的项目，减少重复的CRUD操作代码。
• 复杂查询：适用于需要执行复杂查询的场景，MyBatis Plus的条件构造器和自定义SQL功能可以帮助简化查询逻辑。
• 性能优化：使用分页插件和查询缓存等功能，可以提高应用的性能。
• 代码维护：逻辑删除和自动填充等功能可以简化代码维护工作，使得代码更加简洁和易读。
• 数据校验：在插入或更新数据时，可以自动填充一些字段，如创建时间、更新时间等，减少开发工作量。

MyBatis Plus环境搭建 开发环境准备

1. IDE准备：推荐使用IntelliJ IDEA或Eclipse等IDE。
2. Java环境安装：确保Java环境已经安装并配置好，建议使用Java 8或以上版本。
3. 数据库准备：准备一个关系型数据库，如MySQL，确保数据库服务已经启动。

引入MyBatis Plus依赖

在项目中引入MyBatis Plus的相关依赖，根据使用的构建工具不同，引入方式也有所不同。

Maven项目

在pom.xml文件中添加以下依赖：

<dependencies>
    <!-- 引入Spring Boot Starter Data MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.3</version>
    </dependency>

    <!-- 引入MyBatis Plus的核心依赖 -->
    <dependency>
        <groupId>com.baomidou</groupId>
       .
        .
        .
    </dependency>
</dependencies>

Gradle项目

在build.gradle文件中添加以下依赖：

dependencies {
    implementation 'com.baomidou:mybatis-plus-boot-starter:3.4.3'
    implementation 'com.baomidou:mybatis-plus:3.4.3'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.0'
    implementation 'mysql:mysql-connector-java:8.0.23'
    implementation 'org.springframework.boot:spring-boot-starter:2.6.3'
}

配置数据库连接信息

在application.properties或application.yml文件中配置数据库连接信息。

application.properties

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

application.yml

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

创建数据库表和实体类

创建一个简单的数据库表和对应的实体类。

数据库表

使用以下SQL创建一个名为user的表：

CREATE TABLE `user` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(50) DEFAULT NULL,
  `age` INT(11) DEFAULT NULL,
  `email` VARCHAR(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

实体类

创建对应的实体类，并使用@TableName注解指定表名。

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;

@TableName("user")
public class User implements Serializable {
    @TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;

    // Getter和Setter方法
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

MyBatis Plus基本操作 增加数据操作

使用MyBatis Plus可以方便地进行插入数据的操作。这里我们通过User实体类来演示插入操作。

插入数据

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
    public void insertUser() {
        User user = new User();
        user.setName("Zhang San");
        user.setAge(20);
        user.setEmail("zhangsan@example.com");

        boolean success = this.save(user);
        System.out.println("数据插入是否成功：" + success);
    }
}

修改数据操作

MyBatis Plus也提供了便捷的方式来修改数据。通过构建一个UpdateWrapper对象可以方便地更新数据。

修改数据

public void updateUser() {
    User user = new User();
    user.setId(1L);
    user.setName("Zhang San Updated");
    user.setAge(22);
    user.setEmail("zhangsanupdated@example.com");

    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.eq("id", 1L);
    boolean success = this.update(user, updateWrapper);
    System.out.println("数据更新是否成功：" + success);
}

删除数据操作

删除数据操作也十分简单，只需构建一个UpdateWrapper并指定需要删除的条件。

删除数据

public void deleteUser() {
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.eq("id", 1L);
    boolean success = this.remove(updateWrapper);
    System.out.println("数据删除是否成功：" + success);
}

查询数据操作

查询数据操作支持多种方式，从简单的单表查询到复杂的多表联查。

查询单条数据

public User findUserById(Long id) {
    return this.getOne(Wrappers.<User>lambdaQuery().eq(User::getId, id));
}

查询多条数据

public List<User> findUsers() {
    return this.list(Wrappers.<User>lambdaQuery().gt(User::getAge, 18));
}

分页查询

分页查询是数据库操作中常见的需求，MyBatis Plus提供了一套完善的分页插件。

分页查询

public Page<User> findUsersPage(int currentPage, int pageSize) {
    Page<User> page = new Page<>(currentPage, pageSize);
    this.page(page, Wrappers.<User>lambdaQuery().ge(User::getAge, 18));
    return page;
}

MyBatis Plus高级功能 条件构造器（Wrapper）使用

条件构造器（Wrapper）是MyBatis Plus提供的一个强大的工具，用于构建复杂的查询条件。

使用条件构造器

public List<User> findUsersByWrapper() {
    Wrapper<User> wrapper = Wrappers.<User>lambdaQuery()
        .eq(User::getAge, 20)
        .or()
        .eq(User::getEmail, "zhangsan@example.com");
    return this.list(wrapper);
}

自动填充与逻辑删除

自动填充

自动填充功能可以自动填充一些特定的字段，例如创建时间、更新时间等。

配置自动填充

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import java.util.Date;

@TableName("user")
public class User {
    @TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;

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

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

    // Getter和Setter方法
}

自定义填充策略

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import java.util.Date;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;

public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", new Date(), metaObject);
    }

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

逻辑删除

逻辑删除是指不真正从数据库中删除记录，而是将记录标记为删除状态。

配置逻辑删除

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import java.util.Date;

@TableName("user")
public class User {
    @TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @TableLogic
    private Integer deleted;

    // Getter和Setter方法
}

查询逻辑删除数据

public List<User> findUsersWithLogicDelete() {
    Wrapper<User> wrapper = Wrappers.<User>lambdaQuery()
        .eq(User::getDeleted, 0);
    return this.list(wrapper);
}

自定义SQL执行

自定义SQL执行可以满足更复杂的数据操作需求。

自定义SQL执行

public List<User> customSqlQuery() {
    String sql = "SELECT * FROM user WHERE age > ?";
    return this.sqlSelectList(sql, 18);
}

代码生成器使用

代码生成器允许自动生成实体类、Mapper接口和Mapper XML文件。

使用代码生成器

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.IPackageConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;
import java.util.Date;

public class CodeGenerator {
    public static void main(String[] args) {
        AutoGenerator mpg = new AutoGenerator();

        // 1、全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir(System.getProperty("user.dir") + "/src/main/java");
        gc.setAuthor("YourName");
        gc.setFileOverride(true);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setActiveRecord(true);
        gc.setEnableCache(false);
        gc.setBaseResultMap(true);
        gc.setBaseColumnList(true);
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 2、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDbType(DbType.MYSQL);
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC");
        mpg.setDataSource(dsc);

        // 3、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.example");
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setXml("mapper/xml");
        mpg.setPackageInfo(pc);

        // 4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        strategy.setInclude("user");
        strategy.setController("UserController");
        strategy.setTableFill(new TableFill("create_time", FieldFill.INSERT));
        strategy.setTableFill(new TableFill("update_time", FieldFill.INSERT_UPDATE));
        mpg.setStrategy(strategy);

        // 5、执行
        mpg.execute();
    }
}

MyBatis Plus与Spring Boot集成 Spring Boot项目搭建

搭建一个Spring Boot项目，并集成MyBatis Plus。

创建Spring Boot项目

使用Spring Initializr或IDE内置的Spring Boot初始化工具创建一个新的Spring Boot项目。

添加依赖

在pom.xml或build.gradle文件中添加Spring Boot和MyBatis Plus的依赖。

配置application.properties或application.yml

配置数据库连接信息。

配置Mapper接口

创建对应的Mapper接口和实现类。

配置启动类

在Spring Boot启动类中添加相应的配置。

Spring Boot中集成MyBatis Plus

1. 配置数据源：在application.properties或application.yml文件中添加数据库连接信息。
2. 创建Mapper接口：创建对应的Mapper接口和实现类。
3. 配置Mapper扫描：在Spring Boot启动类中添加@MapperScan注解配置Mapper接口的扫描路径。

启动类配置

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.mapper")
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}

实战案例：CRUD操作

通过一个简单的CRUD操作案例来展示如何在Spring Boot中使用MyBatis Plus。

创建实体类

创建一个用户实体类。

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;

@TableName("user")
public class User implements Serializable {
    @TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;

    // Getter和Setter方法
}

创建Mapper接口

创建Mapper接口，并继承BaseMapper接口。

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

创建Service类

创建Service类，并继承ServiceImpl类。

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
    public void insertUser() {
        User user = new User();
        user.setName("Zhang San");
        user.setAge(20);
        user.setEmail("zhangsan@example.com");

        boolean success = this.save(user);
        System.out.println("数据插入是否成功：" + success);
    }
}

创建Controller类

创建Controller类，提供CRUD操作接口。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping
    public void insertUser() {
        userService.insertUser();
    }

    @GetMapping("/{id}")
    public User findUserById(@PathVariable Long id) {
        return userService.getById(id);
    }

    @PutMapping("/{id}")
    public void updateUser(@PathVariable Long id) {
        User user = new User();
        user.setId(id);
        user.setName("Zhang San Updated");
        user.setAge(22);
        user.setEmail("zhangsanupdated@example.com");

        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", id);
        userService.update(user, updateWrapper);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", id);
        userService.remove(updateWrapper);
    }
}

整合JPA规范

MyBatis Plus可以与JPA规范结合使用，以提供更丰富、更灵活的数据访问功能。

配置JPA

在application.properties或application.yml文件中配置JPA的启用。

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

使用JPA规范

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserJpaRepository extends JpaRepository<User, Long> {
}

常见问题与调试技巧 常见错误与解决方法

1. 找不到实体类：检查实体类的包名是否正确，确保实体类被正确扫描。
2. SQL执行错误：检查SQL语句是否正确，确保数据库表结构与实体类一致。

示例错误

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userService': Injection of autowired dependencies failed

解决方法

检查UserService类中的依赖注入是否正确。

日志查看与调试

1. 配置日志：在application.properties文件中配置日志级别。
2. 查看日志：通过控制台输出或日志文件查看详细的日志信息。

配置日志

logging.level.com.example=DEBUG

查看日志

# 控制台输出日志
logging.level.org.mybatis.spring.SqlSessionUtils=DEBUG

# 日志文件输出
logging.file=/var/log/mybatis_plus.log

性能优化建议

1. 分页查询：合理使用分页查询功能，避免一次性加载大量数据。
2. 缓存机制：使用缓存机制减少数据库访问次数。

使用缓存

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
    @Cacheable(value = "userCache", key = "#id")
    public User findUserById(Long id) {
        return this.getById(id);
    }
}

代码规范与维护

1. 命名规范：遵守Java命名规范，确保代码的可读性和可维护性。
2. 注释规范：合理使用注释，提高代码的可读性和可维护性。

命名规范示例

public class UserService extends ServiceImpl<UserMapper, User> {
    public void insertUser() {
        User user = new User();
        // 代码逻辑
    }
}

注释规范示例

/**
 * 插入用户数据
 * @param user 用户对象
 * @return 插入是否成功
 */
public void insertUser(User user) {
    boolean success = this.save(user);
    System.out.println("数据插入是否成功：" + success);
}