MyBatis Plus入门指南：轻松搭建高效持久层框架

概述

MyBatis Plus 是一个增强的 MyBatis 框架，旨在简化开发并提高效率。它提供了丰富的内置CRUD操作方法、支持Lambda表达式查询及链式操作，使MyBatis的使用更加便捷。MyBatis Plus依然遵循MyBatis的编程模型，通过扩展SqlSession和SqlSessionFactory实现增强，屏蔽了底层细节，提升了开发效率和代码质量。

MyBatis Plus简介

MyBatis Plus是什么

MyBatis Plus 是一个 MyBatis 的增强工具，旨在简化开发和提高效率。它在 MyBatis 的基础上提供了大量的内置 CRUD 操作方法，支持 Lambda 表达式查询，提供链式操作，支持自定义主键生成策略等，使 MyBatis 的使用更加便捷，同时避免了大量的重复代码。

MyBatis Plus 依然遵循 MyBatis 的编程模型，通过扩展 SqlSession 和 SqlSessionFactory 实现对 MyBatis 的增强。它屏蔽了 MyBatis 的底层细节，提供了一些默认的实现，开发者只需要关注业务逻辑，这使得开发效率和代码质量得到了显著提升。

MyBatis Plus与MyBatis的关系

MyBatis Plus 是 MyBatis 的一个扩展，它在 MyBatis 的基础上做了若干功能增强。MyBatis Plus 保留了 MyBatis 的核心功能，同时增加了许多便捷的方法和功能，使得开发人员可以快速完成 CRUD 操作，极大提高了开发效率。MyBatis Plus 与 MyBatis 的关系类似于插件与核心库的关系，插件增强了核心库的功能，但仍然依赖于核心库。

在使用 MyBatis Plus 时，需要引入 MyBatis Plus 的依赖，同时仍然需要配置 MyBatis 的核心配置，如数据库连接信息、MyBatis 的配置文件等。MyBatis Plus 提供了一些默认配置，但这些配置仍然可以被覆盖，以适应不同的项目需求。MyBatis Plus 的核心特性包括：

• CRUD 操作：提供了丰富的 CRUD 方法，使得增删改查操作更加便捷。
• 自定义主键生成：支持多种主键生成策略，如 UUID、雪花算法等。
• 条件构造器：提供了一套强大的条件构造器，可以方便地构建复杂的查询条件。
• 链式操作：支持链式调用，提供了一种更为优雅的方法调用方式。
• 分页：内置了多种分页实现，支持多种分页插件。
• 逻辑删除：提供了一套逻辑删除的实现，使得删除操作更加灵活。

由于 MyBatis Plus 与 MyBatis 的紧密联系，开发者可以无缝切换到 MyBatis Plus，同时保留原有的 MyBatis 代码，这使得迁移成本大大降低。因此，MyBatis Plus 是 MyBatis 的一个有力补充，可以显著提升开发效率。

MyBatis Plus的优势

MyBatis Plus 提供了许多优势，使其成为开发人员的首选持久层框架之一。以下是 MyBatis Plus 的主要优势：

操作便捷

MyBatis Plus 提供了大量的内置方法，使 CRUD 操作变得更加简单。例如，它提供了一个 Mapper 接口，通过继承 BaseMapper，可以自动获得所有 CRUD 操作的实现，如 insert, update, delete 和 select 等。以下是一个简单的示例：

public interface UserMapper extends BaseMapper<User> {
}

通过这种方式，你无需编写任何 SQL，MyBatis Plus 会自动生成相应的 SQL 语句来执行这些操作。

提高开发效率

MyBatis Plus 的一大优势是它可以显著提高开发效率，尤其是在处理 CRUD 操作时。例如，它提供了链式调用的能力，使得查询操作更加简洁和易读。下面是一个简单的链式调用示例：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq("name", "张三")
    .and(i -> i.gt("age", 18))
    .orderByAsc("age"));

通过以上代码，你可以轻松地进行复杂的查询操作，同时保持代码的可读性和简洁性。

丰富的查询方式

MyBatis Plus 提供了多种查询方式，包括 Lambda 表达式、条件构造器等，这些方式使得查询操作更加灵活和强大。例如，你可以使用条件构造器来构建复杂的查询条件：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq("name", "张三")
    .and(i -> i.gt("age", 18))
    .orderByAsc("age"));

条件构造器可以组合多个条件，支持 and, or, eq, ne, gt, lt 等多种操作符，这使得查询操作更加灵活和强大。

自定义主键生成策略

MyBatis Plus 支持多种主键生成策略，包括自增、UUID、雪花算法等。这使得主键生成更加灵活和强大。例如，你可以通过配置文件来指定主键生成策略：

mybatis-plus:
  global-config:
    db-config:
      id-type: ASSIGN_UUID

这样，MyBatis Plus 会使用 UUID 策略来生成主键。

分页插件支持

MyBatis Plus 内置了多种分页实现，支持多种分页插件，如 PageHelper 和 MyBatis Plus Page。这使得分页查询更加方便和强大。例如，你可以使用 MyBatis Plus 内置的分页插件来支持分页查询：

Page<User> page = new Page<>(1, 10);
IPage<User> result = userMapper.selectPage(page, new QueryWrapper<User>());

通过以上代码，你可以轻松地进行分页查询操作，同时保持代码的可读性和简洁性。

集成方式简单

MyBatis Plus 的集成方式非常简单，只需要在项目中添加依赖，并配置数据库连接信息即可。例如，你可以在 pom.xml 中添加如下依赖：

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

同时，在 application.yml 中配置数据库连接信息：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_plus
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

通过以上步骤，你可以轻松地将 MyBatis Plus 集成到你的项目中。

逻辑删除支持

MyBatis Plus 提供了逻辑删除的支持，这使得删除操作更加灵活和强大。例如，你可以通过配置文件来启用逻辑删除：

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

通过以上配置，MyBatis Plus 会将逻辑删除字段设置为 1，逻辑未删除字段设置为 0，这使得删除操作更加灵活和强大。

Lambda 表达式支持

MyBatis Plus 提供了 Lambda 表达式支持，这使得查询操作更加简洁和易读。例如，你可以使用 Lambda 表达式来构建复杂的查询条件：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq(User::getName, "张三")
    .and(i -> i.gt(User::getAge, 18))
    .orderByAsc(User::getAge));

通过以上代码，你可以轻松地进行复杂的查询操作，同时保持代码的可读性和简洁性。

环境搭建

准备工作

在开始使用 MyBatis Plus 之前，你需要确保已经安装了 Java 开发环境，并且熟悉基本的 Java 开发工具，如 IDE（IntelliJ IDEA 或 Eclipse）等。此外，还需要安装数据库软件，如 MySQL，并创建一个数据库。

安装数据库

首先，安装 MySQL 数据库，并创建一个数据库实例。你可以使用 SQL 命令来完成这些操作，例如：

CREATE DATABASE mybatis_plus;

USE mybatis_plus;

CREATE TABLE user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL,
    age INT NOT NULL,
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    deleted Integer DEFAULT 0
);

这样就创建了一个简单的用户表，其中包含 id, name, age, create_time 和 update_time 字段。

添加依赖

接下来，你需要在你的 Spring Boot 项目中添加 MyBatis Plus 依赖。如果你使用的是 Maven，可以在 pom.xml 文件中添加以下依赖：

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

如果你使用的是 Gradle，可以在 build.gradle 文件中添加以下依赖：

dependencies {
    implementation 'com.baomidou:mybatis-plus-boot-starter:3.4.3'
}

这些依赖将自动引入 MyBatis Plus 所需的所有库和配置。

配置数据库连接

在 Spring Boot 项目中，你需要在 application.yml 文件中配置数据库连接信息，以便 MyBatis Plus 能够连接到数据库。以下是一个示例配置：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_plus
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

此外，你还需要配置 MyBatis Plus 的一些全局配置，例如主键生成策略、逻辑删除字段等。你可以在 application.yml 文件中添加以下配置：

mybatis-plus:
  global-config:
    db-config:
      id-type: ASSIGN_UUID
      logic-delete-value: 1
      logic-not-delete-value: 0

这些配置将启用 UUID 作为主键生成策略，并启用逻辑删除功能。

基本使用

在完成环境搭建后，你可以开始使用 MyBatis Plus 进行基本的 CRUD 操作了。以下是具体步骤：

创建实体类

你需要创建一个实体类，该类将映射到数据库中的表。以下是一个简单的用户实体类示例：

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

import java.time.LocalDateTime;

@TableName("user")
public class User {
    @TableId(value = "id", type = TableId.Type.AUTO)
    private Long id;
    private String name;
    private int age;
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
    @TableLogic
    private Integer deleted;

    // Getter 和 Setter 方法
}

在这个示例中，@TableName 注解指定了数据库表名，字段上使用的 @TableId 注解指定了主键字段，@TableField 注解用于指定其他字段的映射和填充时机，@TableLogic 注解用于逻辑删除字段。

创建Mapper接口

接下来，你需要创建一个 Mapper 接口，该接口将用于执行数据库操作。以下是一个简单的 UserMapper 接口示例：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    /**
     * 自定义查询方法
     * @param name
     * @param age
     * @return
     */
    List<User> selectByNameAndAge(String name, Integer age);
}

在这个示例中，UserMapper 继承了 BaseMapper<User>，这使得你可以自动获得所有 CRUD 操作的实现。此外，你还可以定义自定义的方法，如 selectByNameAndAge，这将执行一个自定义的查询。

基本CRUD操作

接下来，你可以使用 UserMapper 接口进行基本的 CRUD 操作。

插入数据

首先，你可以插入一条数据：

User user = new User();
user.setName("张三");
user.setAge(18);
userMapper.insert(user);

这段代码将创建一个新的用户对象，并插入到数据库中。

查询数据

你可以查询所有用户，或者根据条件查询用户：

// 查询所有用户
List<User> users = userMapper.selectList(null);

// 根据条件查询用户
List<User> usersByNameAndAge = userMapper.selectByNameAndAge("张三", 18);

更新数据

你可以更新一条数据：

User user = new User();
user.setId(1L);
user.setName("李四");
user.setAge(20);
userMapper.updateById(user);

这段代码将更新指定 ID 的用户信息。

删除数据

你可以删除一条数据：

userMapper.deleteById(1L);

这段代码将删除指定 ID 的用户。

逻辑删除数据

MyBatis Plus 支持逻辑删除，你可以使用逻辑删除操作：

User user = new User();
user.setId(1L);
user.setDeleted(1);
userMapper.updateById(user);

这段代码将逻辑删除指定 ID 的用户。

功能扩展

MyBatis Plus 提供了多种功能扩展，使得你可以更加灵活地处理复杂查询和业务逻辑。

分页查询

分页查询是常用的数据库操作之一。MyBatis Plus 提供了内置的分页插件，使得分页查询更加方便。以下是一个简单的分页查询示例：

Page<User> page = new Page<>(1, 10);
IPage<User> result = userMapper.selectPage(page, new QueryWrapper<User>());

这段代码将查询第 1 页，每页 10 条数据。

自定义分页插件

MyBatis Plus 还支持自定义分页插件。你可以通过实现 IPageInterceptor 接口来添加自定义的分页逻辑。例如，以下示例展示了如何实现一个简单的分页拦截器：

import com.baomidou.mybatisplus.extension.plugins.pagination.PageInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageInnerInterceptor;

import java.util.Properties;

public class CustomPageInterceptor extends PageInnerInterceptor {

    @Override
    public void setProperties(Properties properties) {
        super.setProperties(properties);
    }

    @Override
    public void intercept(SqlMethod sqlMethod, Object... parameters) {
        // 自定义分页逻辑
        super.intercept(sqlMethod, parameters);
    }
}

然后在配置文件中启用自定义分页插件：

mybatis-plus:
  plugin:
    page:
      enabled: true
      interceptor: com.example.CustomPageInterceptor

条件构造器

条件构造器是 MyBatis Plus 的一大亮点，它提供了一套强大且灵活的条件构建工具。以下是一个条件构造器的使用示例：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq("name", "张三")
    .and(i -> i.gt("age", 18))
    .orderByAsc("age"));

在这个示例中，我们使用了 eq 方法来指定 name 等于 "张三"，gt 方法来指定 age 大于 18，orderByAsc 方法来指定按 age 升序排序。

复杂条件构建

条件构造器还可以构建更复杂的条件。例如，你可以使用 and 方法组合多个条件：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq("name", "张三")
    .and(i -> i.gt("age", 18))
    .or(i -> i.lt("age", 12))
    .orderByAsc("age"));

在这个示例中，条件为 name 等于 "张三" 且年龄大于 18 或年龄小于 12，并按 age 升序排序。

自定义逻辑

除了内置的功能外，MyBatis Plus 还允许你自定义逻辑。例如，你可以通过继承 BaseMapper 并实现自定义的方法来实现更复杂的业务逻辑。以下是一个自定义方法的示例：

public interface UserMapper extends BaseMapper<User> {
    /**
     * 自定义查询方法
     * @param name
     * @param age
     * @return
     */
    List<User> selectByNameAndAge(String name, Integer age);
}

你可以在实现类中实现这个方法：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public class UserMapperImpl extends ServiceImpl<UserMapper, User> implements UserMapper {
    @Override
    public List<User> selectByNameAndAge(String name, Integer age) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name)
                   .and(i -> i.gt("age", age));
        return list(queryWrapper);
    }
}

在这个示例中，selectByNameAndAge 方法通过 QueryWrapper 构建查询条件，并调用 list 方法执行查询。

实际案例

为了更好地理解 MyBatis Plus 的使用，我们将通过一个简单的项目实战来展示其功能。

简单项目实战

我们将创建一个简单的用户管理系统，该系统包含用户信息的增删改查功能，并使用分页插件进行分页查询。

创建项目结构

首先，创建一个简单的项目结构，包含以下几个主要部分：

• User 实体类
• UserMapper 接口
• UserService 服务层
• UserController 控制层

实体类

定义一个 User 实体类：

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

import java.time.LocalDateTime;

@TableName("user")
public class User {
    @TableId(value = "id", type = TableId.Type.AUTO)
    private Long id;
    private String name;
    private int age;
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
    @TableLogic
    private Integer deleted;

    // Getter 和 Setter 方法
}

Mapper接口

定义一个 UserMapper 接口：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    /**
     * 自定义查询方法
     * @param name
     * @param age
     * @return
     */
    List<User> selectByNameAndAge(String name, Integer age);
}

服务层

定义一个 UserService 服务层，用于业务逻辑处理：

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {

    public List<User> getUserList() {
        return selectList(null);
    }

    public Page<User> getUserPage(Page<User> page) {
        return selectPage(page, new QueryWrapper<User>());
    }

    public boolean addUser(User user) {
        return insert(user) > 0;
    }

    public boolean updateUser(User user) {
        return updateById(user) > 0;
    }

    public boolean deleteUser(Long id) {
        return deleteById(id) > 0;
    }

    public List<User> getUserByNameAndAge(String name, Integer age) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name)
                   .and(i -> i.gt("age", age));
        return selectList(queryWrapper);
    }
}

控制层

定义一个 UserController 控制层，用于处理 HTTP 请求：

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/list")
    public List<User> getUserList() {
        return userService.getUserList();
    }

    @GetMapping("/page")
    public Page<User> getUserPage(@RequestParam int currentPage, @RequestParam int pageSize) {
        return userService.getUserPage(new Page<>(currentPage, pageSize));
    }

    @PostMapping("/add")
    public boolean addUser(@RequestBody User user) {
        return userService.addUser(user);
    }

    @PutMapping("/update")
    public boolean updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @DeleteMapping("/delete/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.deleteUser(id);
    }

    @GetMapping("/search")
    public List<User> getUserByNameAndAge(@RequestParam String name, @RequestParam Integer age) {
        return userService.getUserByNameAndAge(name, age);
    }
}

配置文件

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

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_plus
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  global-config:
    db-config:
      id-type: ASSIGN_UUID
      logic-delete-value: 1
      logic-not-delete-value: 0

运行项目

你可以使用 Spring Boot 的命令行工具或者 IDE 来运行项目。启动项目后，你可以通过浏览器或 POSTMAN 等工具访问相应的接口，如：

• GET /user/list：获取所有用户
• GET /user/page?page=1&size=10：获取第 1 页，每页 10 条数据
• POST /user/add：新增用户
• PUT /user/update：更新用户
• DELETE /user/delete/{id}：删除用户
• GET /user/search?name=张三&age=18：查询指定名字和年龄的用户

遇到的问题及解决办法

在实际项目开发中，你可能会遇到一些问题，以下是一些常见问题及其解决办法：

问题1：数据库表名与实体类不匹配

如果你在实际项目中发现数据库表名与实体类注解不匹配，可以通过 @TableName 注解来指定表名：

@TableName("user")
public class User {
    // ...
}

问题2：查询结果为空

如果你发现查询结果为空，但数据库中有数据，可能是查询条件有误。你可以使用条件构造器来构建查询条件，确保条件正确：

List<User> users = userMapper.selectList(new QueryWrapper<User>()
    .eq("name", "张三")
    .and(i -> i.gt("age", 18)));

问题3：分页插件未生效

如果你发现分页插件未生效，可以检查配置文件是否正确配置了分页插件：

mybatis-plus:
  plugin:
    page:
      enabled: true

问题4：查询性能问题

如果你发现查询性能问题，可以考虑使用缓存策略。MyBatis Plus 支持多种缓存插件，如 Redis 缓存插件：

mybatis-plus:
  plugin:
    redis-cache:
      enabled: true

总结与展望

MyBatis Plus的总结

MyBatis Plus 是一个强大的 MyBatis 增强工具，它提供了丰富的内置方法和便捷的查询方式，使得 CRUD 操作变得简单高效。MyBatis Plus 的主要特点包括：

• 内置方法：提供了丰富的内置 CRUD 方法，减少了大量的重复代码。
• Lambda 表达式支持：支持 Lambda 表达式查询，使得查询条件更加简洁。
• 条件构造器：提供了一套强大的条件构造器，可以构建复杂的查询条件。
• 自定义主键生成策略：支持多种主键生成策略，如 UUID、雪花算法等。
• 逻辑删除：支持逻辑删除，使得删除操作更加灵活。
• 分页插件：内置了多种分页插件，支持多种分页实现。

MyBatis Plus 的这些特性使得它在实际项目开发中能够显著提高开发效率和代码质量，同时减少了代码量，提升了项目的可维护性。

MyBatis Plus未来的发展方向

随着技术的不断进步，MyBatis Plus 也在不断地进行改进和完善。未来的发展方向可能包括：

• 更多内置方法：继续开发更多的内置方法，以满足不同场景的需求。
• 更强大的条件构造器：优化和增强条件构造器，支持更多复杂的查询条件。
• 更丰富的插件支持：提供更多内置插件，如 Redis 缓存插件、ShardingSphere 分库分表插件等。
• 更好的性能优化：不断优化性能，提升查询效率，减少数据库压力。
• 更好的兼容性和扩展性：提高与其他框架和工具的兼容性，支持更多的数据库类型。
• 更好的开发者体验：持续优化开发者体验，提供更友好的配置和使用方式。