mybatis plus 常用知识汇总（保姆级教程！~）

介绍：

MyBatis-Plus 是基于 MyBatis 框架的一个增强工具，主要目的是简化 MyBatis 的开发过程，提供更加简洁、方便的 CRUD 操作。它是在保留 MyBatis 强大功能的基础上，通过封装和优化一些常见操作来提高开发效率。

MyBatis-Plus 提供了许多开箱即用的功能，包括自动 CRUD 代码生成、分页查询、性能优化、以及支持多种数据库。与 MyBatis 相比，MyBatis-Plus 的 部分 核心特性包括：

  1. 无侵入设计：不会改变 MyBatis 原有的 API 和使用方式，你可以自由选择 MyBatis 和 MyBatis-Plus 的功能。
  2. 自动 CRUD：通过 BaseMapper 和 ServiceImpl 接口，MyBatis-Plus 提供了一系列 CRUD 操作的方法，如 insert、delete、update 和 select，减少了重复的 SQL 编写工作。
  3. 条件构造器：MyBatis-Plus 提供了条件构造器（如 QueryWrapper），可以通过链式编程方式轻松构建复杂的查询条件。

1、准备工作

1.1 添加依赖

创建一个 springboot 项目， 在 pom.xml 文件中的 dependencies 标签中添加所需要的依赖。
打开 maven官网 搜索所需依赖。大家添加最新版本的就行

  • mybatis plus

在这里插入图片描述
在这里插入图片描述

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

  • mysql

在这里插入图片描述

在这里插入图片描述

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>9.0.0</version>
</dependency>

  • mybatis spring

这个依赖最好加上，它可以解决部分 mybatis 和 spring 之间的兼容性问题

在这里插入图片描述
在这里插入图片描述

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>3.0.4</version>
</dependency>

1.2 创建数据表和数据

在 mybatis plus 官网 给的有 sql 语句, 执行生成数据表和数据

在这里插入图片描述

在 application.properties 文件中添加下面信息连接数据库

spring.datasource.url=jdbc:mysql://localhost:3306/yourDatabaseName?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=YourUserName
spring.datasource.password=YourPassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

idea连接数据库，创建pojo，mapper，service，controller文件就不多赘述了..

2、mapper层基本的操作

BaseMapper 是 MyBatis-Plus 提供的一个基础 Mapper 接口，它简化了数据访问层（Data Access Layer）的开发。BaseMapper 提供了一系列通用的数据库操作方法，这样你就不必手动编写常见的 SQL 语句，从而提升了开发效率。

1. 使用 BaseMapper

假设我们有一个用户实体类 User，如下：

public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
    // Getter 和 Setter
}

你可以创建一个 UserMapper 接口来继承 BaseMapper<User>：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
    // 你可以在这里添加自定义方法
}

通过继承 BaseMapper<User>，UserMapper 立即拥有了所有的 CRUD 操作方法。你可以在你的服务层（Service Layer）中直接使用这些方法，无需再编写任何 SQL 语句。

2. BaseMapper 提供的常用方法

2.1 增（Insert）

简单示例：

// 定义用户实体类
public class User {
    private Long id;
    private String username;
    private String email;
}

// 使用 MyBatis-Plus 提供的 BaseMapper 接口
public interface UserMapper extends BaseMapper<User> {
}

// 插入一条记录
User user = new User();
user.setUsername("john_doe");
user.setEmail("john@example.com");

// 调用 insert 方法
userMapper.insert(user);

解释：这里的 insert 方法直接使用实体类对象 user，将其插入到数据库中。MyBatis-Plus 自动生成的 insert 方法会根据实体类的属性映射到数据库表的字段。

2.2 删（Delete）

简单示例：

// 根据 ID 删除一条记录
userMapper.deleteById(1L);

解释：deleteById 方法通过传入用户的 id 删除该用户。这个方法直接删除主键为 1 的用户。

2.3 改（Update）

简单示例：

// 创建一个用户对象，设置要修改的字段
User user = new User();
user.setId(1L);  // 设置要更新的用户 ID
user.setEmail("newemail@example.com");  // 修改用户邮箱

// 更新用户信息
userMapper.updateById(user);

解释：updateById 方法根据 id 更新用户记录，这里只更新了邮箱字段，其他字段保持不变。

2.4 查（Select）

简单示例：

// 根据 ID 查询用户
User user = userMapper.selectById(1L);

// 输出用户信息
System.out.println(user.getUsername());

解释：selectById 方法根据传入的 id 查询对应的用户信息，然后可以输出或使用这个用户信息。

2.5 条件查询

简单示例：

// 构建查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); // <-------- 下面会讲到 

queryWrapper.eq("username", "john_doe");  // 设置条件：用户名为 john_doe

// 执行查询
List<User> users = userMapper.selectList(queryWrapper);

// 输出查询结果
for (User u : users) {
    System.out.println(u.getUsername());
}

解释：QueryWrapper 是 MyBatis-Plus 提供的一个工具类，用于构建查询条件。selectList 方法根据条件查询所有符合条件的记录。

3. Mybatis 的补充

在 Java 接口中使用注解来编写 SQL。

2. 常用注解

@Select

用于执行 SQL 查询并返回结果。

@Select("SELECT * FROM table_name WHERE id = #{id}")
Object selectById(@Param("id") Integer id);
  • #{id}：表示占位符，表示将会被参数 id 的值替换。

@Insert

用于执行插入操作。

@Insert("INSERT INTO table_name (column1, column2) VALUES (#{value1}, #{value2})")
void insert(@Param("value1") String value1, @Param("value2") Integer value2);

@Update

用于执行更新操作。

@Update("UPDATE table_name SET column1 = #{value1} WHERE id = #{id}")
void update(@Param("id") Integer id, @Param("value1") String value1);

@Delete

用于执行删除操作。

@Delete("DELETE FROM table_name WHERE id = #{id}")
void delete(@Param("id") Integer id);

3. 参数传递

在使用注解时，方法参数可以通过 @Param 注解进行命名，从而在 SQL 中使用。

public interface MyMapper {
    @Select("SELECT * FROM users WHERE username = #{username} AND age = #{age}")
    User selectByUsernameAndAge(@Param("username") String username, @Param("age") Integer age);
}

在这里，@Param("username") 和 @Param("age") 用于将方法参数与 SQL 查询中的占位符对应起来。

4. 返回值处理

SQL 查询的返回值可以是单个对象、多个对象的列表或简单的原始类型（如 int、String 等）。

  • 单个对象：

    @Select("SELECT * FROM users WHERE id = #{id}")
User selectById(@Param("id") Integer id);

  • 列表：

    @Select("SELECT * FROM users")
List<User> selectAll();

  • 原始类型：

    @Select("SELECT COUNT(*) FROM users")
int countUsers();

5. 事务处理

在使用注解定义 SQL 查询时，事务管理通常在服务层进行。你可以使用 Spring 的 @Transactional 注解来管理事务。

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
        // 其他逻辑...
    }
}

3、service层基本的操作

ServiceImpl 和 IService 是 MyBatis-Plus 中用于服务层（Service Layer）的两个重要接口和类，它们帮助简化和规范了与数据库交互的业务逻辑。下面是它们的详细介绍：

1. IService 接口

IService 是 MyBatis-Plus 提供的一个通用服务接口。它定义了一些常见的 CRUD（Create, Read, Update, Delete）操作，并将这些操作抽象成方法。这意味着，当你使用 IService 接口时，你无需自己手动编写这些常见的数据库操作方法。

IService 中的一些常用方法：

  • boolean save(T entity): 保存一个实体类对象到数据库。
  • boolean removeById(Serializable id): 根据 ID 删除数据。
  • boolean updateById(T entity): 根据 ID 更新数据。
  • T getById(Serializable id): 根据 ID 查询数据。
  • List<T> list(): 查询所有数据。
  • Page<T> page(Page<T> page): 分页查询数据。

2. ServiceImpl 类

ServiceImpl 是 MyBatis-Plus 提供的一个基础实现类，它实现了 IService 接口中的方法。ServiceImpl 通常是被继承的，它提供了具体的数据库操作方法的实现。开发者只需在自己定义的服务实现类中继承 ServiceImpl 类，就可以获得默认的 CRUD 功能。

使用示例

假设你有一个用户表 User，并为其定义了一个实体类 User 和一个 Mapper 接口 UserMapper。你可以定义一个服务接口 UserService 和一个服务实现类 UserServiceImpl。

1. 定义服务接口：

public interface UserService extends IService<User> {
    // 可以定义一些自定义的服务方法
}

2. 定义服务实现类：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 你可以重写 ServiceImpl 中的方法，或者定义更多的业务逻辑
}

在这个例子中，UserServiceImpl 继承了 ServiceImpl<UserMapper, User> 并实现了 UserService 接口。通过这种方式，UserServiceImpl 类可以直接使用 ServiceImpl 提供的基本 CRUD 方法。

Mapper 和 Service 中有很多的方法，具体用法可以参考 Mybatis plus 官网
在这里插入图片描述

4、字段映射

MyBatis-Plus 的自动映射规则主要涉及如何将数据库表和字段自动映射到 Java 实体类及其属性。

1. 表名与实体类名的映射

  • 默认规则：MyBatis-Plus 默认使用实体类名作为数据库表名的前缀。比如，如果你的实体类名为 User，那么它会映射到名为 user 的数据库表。
  • 自定义规则：你可以使用 @TableName 注解来指定自定义的表名。例如：
    @TableName("sys_user")
public class User {
    // 属性和方法
}

2. @TableField 字段名与属性名的映射

  • 默认规则：字段名和属性名默认是直接映射的。例如，数据库中的 user_name 字段会映射到实体类中的 userName 属性。
  • 驼峰命名规则：MyBatis-Plus 默认启用了驼峰命名转换。即，数据库中的下划线命名（如 user_name）会被自动转换为 Java 属性的驼峰命名（如 userName）。
  • 自定义字段映射：可以使用 @TableField 注解来指定自定义的字段名。例如：
    @TableField("user_name")
private String userName;

@TableField的其他用法:

  1. 如果表中字段存在 sql语句的关键词 ，比如 desc , 那么需要按照下面的写法, 否则mybatis plus 拼接含有 desc字段 的sql语句时会报错

    @TableField("`desc`") 
private String desc;

  2. @TableField(select = false)
    作用：用于指定某个字段在执行 SQL 查询时不参与查询，即在 SELECT 语句中不包含该字段。
    用途：通常用于那些只需要在数据库操作中存在，但不需要在查询结果中显示的字段。例如，逻辑删除字段、内部使用的字段等

    @TableField(select = false)
private Integer age;

  3. @TableField(exist = false)
    作用：用于指定某个字段不对应数据库中的任何字段，即在数据库表中不存在该字段。
    用途：通常用于那些只在 Java 实体中存在的字段，但在数据库表中没有相应的字段。例如，用于计算或临时存储的数据。

    @TableField(exist = false)
private Integer age;

3. 主键的自动映射

在 MyBatis-Plus 中，@TableId 注解用于标识实体类中的主键字段。@TableId 注解有两个主要属性：value 和 type。它们分别用于指定字段名和主键生成策略。

@TableId 注解属性

  1. value:

    • 用途：指定数据库表中的主键列名。它的值应该是数据库表中实际的列名。
    • 示例：如果数据库表中的主键列名是 user_id，则在实体类中可以这样配置：
      @TableId(value = "user_id", type = IdType.ASSIGN_UUID)
private String userId;

  2. type:

    • 用途：指定主键生成策略。MyBatis-Plus 提供了多种主键生成策略，IdType 枚举类定义了这些策略。

    • 常用的生成策略：

      • IdType.AUTO：数据库自动生成（通常是自增长 ID）。
      • IdType.INPUT：用户输入 ID（即需要手动设置）。
      • IdType.ASSIGN_ID：由 MyBatis-Plus 生成的 ID（通常是 UUID）。
      • IdType.ASSIGN_UUID：生成 UUID（字符串类型的唯一 ID）。

    • 示例：如果你想使用 UUID 作为主键，你可以使用 IdType.ASSIGN_UUID：

      @TableId(value = "user_id", type = IdType.ASSIGN_UUID)
private String userId;

5、条件构造器 常用查询

MyBatis-Plus 提供了强大的条件构造器，使得在查询数据库时可以灵活地构建条件，而无需手动编写复杂的 SQL 语句。主要通过 Wrapper 接口及其常用实现类 QueryWrapper 和 LambdaQueryWrapper 来实现条件查询。

1. Wrapper 接口

Wrapper 是 MyBatis-Plus 提供的条件构造器接口，用于构建动态 SQL。它有多个实现类，其中最常用的是 QueryWrapper 和 LambdaQueryWrapper。

2. QueryWrapper

QueryWrapper 是 MyBatis-Plus 提供的一个通用条件构造器，用于以非 Lambda 表达式的方式构建查询条件。

常用方法：

  • eq: 等于
  • ne: 不等于
  • gt: 大于
  • ge: 大于等于
  • lt: 小于
  • le: 小于等于
  • between: 在两者之间
  • like: 模糊查询
  • or: 或条件
  • and: 并且条件
  • orderByAsc: 升序排序
  • orderByDesc: 降序排序
  • in: 在指定范围内
  • inSql: 允许你使用子查询的结果集作为 IN 条件的范围
  • isNull: 判断字段是否为 NULL
  • isNotNull: 判断字段是否不为 NULL

示例：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper
    .eq("name", "张三")  // name 等于 张三。 eq也可以写三个参数, 第一个参数是boolean, false 表示这个条件不起作用, true 表示起作用
    .ge("age", 18)       // age 大于等于 18
    .like("email", "gmail.com")  // email 包含 gmail.com
    .orderByDesc("create_time"); // 按 create_time 降序排列

List<User> users = userMapper.selectList(queryWrapper);

3. LambdaQueryWrapper

LambdaQueryWrapper 是 QueryWrapper 的 Lambda 版本，用于在构建条件时避免使用字符串来指定字段，增加了类型安全性。它推荐使用字段的 Lambda 表达式来构建条件。

示例：

LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>();
lambdaQuery
    .eq(User::getName, "张三")  // name 等于 张三
    .ge(User::getAge, 18)       // age 大于等于 18
    .like(User::getEmail, "gmail.com")  // email 包含 gmail.com
    .orderByDesc(User::getCreateTime); // 按 create_time 降序排列

List<User> users = userMapper.selectList(lambdaQuery);

4. UpdateWrapper 和 LambdaUpdateWrapper

这两个类分别是用于构建更新条件的构造器，功能与 QueryWrapper 和 LambdaQueryWrapper 类似，但用于 UPDATE 操作。

示例：

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper
    .eq("name", "张三")
    .set("age", 30);  // 将年龄更新为 30

userMapper.update(null, updateWrapper);

具体用法可参考 Mybatis plus 官网
在这里插入图片描述

6、高级查询

6.1 分组查询

示例 ：按 age 分组并统计人数

假设你想统计各个年龄段的人数，可以使用如下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("age", "COUNT(*) as count");
queryWrapper.groupBy("age");

List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper);

生成的 SQL：

SELECT age, COUNT(*) as count FROM user GROUP BY age;

6.2 聚合查询

示例 ：按 age 分组并过滤统计结果（HAVING）

如果你只想统计人数大于 1 的年龄段，可以添加 HAVING 条件：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("age", "COUNT(*) as count");
queryWrapper.groupBy("age");
queryWrapper.having("COUNT(*) > 1");

List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper);

生成的 SQL：

SELECT age, COUNT(*) as count FROM user GROUP BY age HAVING COUNT(*) > 1;

6.3 排序查询

示例 1：按 age 升序和 name 升序排序

假设你想首先按用户的年龄升序排序，然后按姓名升序排序，可以使用如下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByAsc("name");

List<User> result = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user ORDER BY age ASC, name ASC;

示例 2：按 age 降序排序

假设你想按用户的年龄降序排序，可以使用如下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("age");

List<User> result = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user ORDER BY age DESC;

示例 3：按 age 升序和 name 降序组合排序

假设你想先按年龄升序排序，再按姓名降序排序，可以使用如下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByDesc("name");

List<User> result = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user ORDER BY age ASC, name DESC;

示例 4：按多字段排序，并指定是否为空

假设你想按 age 升序排序，并希望将 name 为空的记录排在前面，可以使用如下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByAsc("name", true);

List<User> result = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user ORDER BY age ASC, name ASC;

6.4 逻辑查询

func 方法是 MyBatis-Plus 提供的一个非常灵活的功能，它允许你将一段自定义的逻辑包装到查询条件中。这对于需要根据不同的条件来动态构建查询的场景特别有用。下面是对 func 方法的详细解释。

1. func 方法的基本用法

func 方法接收一个 Consumer，该 Consumer 的参数是 QueryWrapper（或 LambdaQueryWrapper）的一个实例。你可以在这个 Consumer 中编写自定义的逻辑，并根据不同的条件来动态地添加或修改查询条件。

语法结构

queryWrapper.func(wrapper -> {
    // 在这里编写自定义逻辑
    if (condition) {
        wrapper.eq("column", value);
    } else {
        wrapper.ne("column", value);
    }
});

主要参数

  • Consumer<QueryWrapper> 或 Consumer<LambdaQueryWrapper>：这是一个函数式接口，允许你传入一个 Lambda 表达式或方法引用。你可以在这个接口的 accept 方法中实现自己的逻辑。

实际应用场景

假设你有一个用户查询接口，允许用户根据不同的条件来过滤结果，例如按 id 或按 name。你可以使用 func 来根据用户输入动态地构建查询条件。

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.func(wrapper -> {
    if (userInput != null && userInput.isValid()) {
        wrapper.eq(User::getName, userInput.getName());
    } else {
        wrapper.ne(User::getId, 1);
    }
});
List<User> users = userMapper.selectList(lambdaQueryWrapper);
  • 示例解释：
    • 如果 userInput 非空且有效，则查询条件为 name = userInput.getName()。
    • 否则，查询条件为 id != 1。

2. and 和 or 的使用

在 MyBatis-Plus 中，and 和 or 用于在构建查询条件时处理多条件的逻辑运算。它们允许你在查询中组合多个条件，以实现复杂的查询逻辑。

and 方法

and 方法用于将多个查询条件通过逻辑“与” (AND) 连接在一起。它将多个条件组合成一个大的 AND 条件，从而要求所有这些条件都必须满足。

示例

假设你有一个 User 表，你想查询年龄大于 20 且名字为 "Jack" 的用户。可以使用以下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20).and(wrapper -> wrapper.eq("name", "Jack"));

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user WHERE age > 20 AND name = 'Jack';

在这个例子中，and 方法的作用是将 .gt("age", 20) 和 .eq("name", "Jack") 这两个条件通过 AND 组合在一起。

or 方法

or 方法用于将多个查询条件通过逻辑“或” (OR) 连接在一起。它将多个条件组合成一个大的 OR 条件，只要其中一个条件满足，就会返回符合的结果。

示例

假设你有一个 User 表，你想查询年龄大于 20 或名字为 "Jack" 的用户。可以使用以下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20).or(wrapper -> wrapper.eq("name", "Jack"));

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user WHERE age > 20 OR name = 'Jack';

在这个例子中，or 方法的作用是将 .gt("age", 20) 和 .eq("name", "Jack") 这两个条件通过 OR 组合在一起。

组合使用 and 和 or

你还可以结合使用 and 和 or 方法，以构建更复杂的查询。例如，如果你想查询年龄大于 20 且（名字为 "Jack" 或邮箱为 "test@example.com"）的用户，可以使用以下代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20)
            .and(wrapper -> wrapper.eq("name", "Jack")
                                    .or().eq("email", "test@example.com"));

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user WHERE age > 20 AND (name = 'Jack' OR email = 'test@example.com');

在这个例子中，and 和 or 方法的结合使用允许你在 age > 20 的基础上，增加一个组合条件 (name = 'Jack' OR email = 'test@example.com')。

6.5 其他查询

apply 方法

apply 方法允许你直接在 QueryWrapper 中插入自定义的 SQL 片段。apply 方法中的 SQL 片段会被添加到 WHERE 子句的末尾。这允许你在现有的查询条件基础上，添加更复杂的条件或函数。

基本用法：

QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.apply("DATE_FORMAT(create_time, '%Y-%m-%d') = {0}", "2024-09-01");

在这个示例中：

  • apply 方法接受一个 SQL 片段作为第一个参数，并可以通过 {} 占位符来插入参数。
  • 这里使用了 DATE_FORMAT 函数来格式化 create_time 字段，并将其与特定的日期进行比较。

last 方法

last 方法用于在生成的 SQL 查询的末尾添加额外的 SQL 片段。通常用于添加额外的 SQL 语句，如 ORDER BY, LIMIT, OFFSET 等，这些操作是在生成的 SQL 的最后部分进行的。

基本用法：

QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.last("LIMIT 5");

在这个示例中：

  • last 方法添加了一个 LIMIT 5 子句到查询的末尾，用于限制结果集的返回行数。

示例

假设你有一个 User 表，并且想要查询所有 age 大于 20 的用户，并且结果按照 id 降序排列，并且只返回前 10 条记录。你可以使用 apply 和 last 方法来实现这个需求：

QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.gt("age", 20) // age > 20
       .orderByDesc("id") // 按 id 降序排序
       .last("LIMIT 10"); // 限制返回结果为前 10 条

以上内容包含了 mybatis plus 的大部分常用内容，基本能满足大部分需求。
其他内容 ... 待更~

posted @ 2024-09-09 16:03  小程xy  阅读(62)  评论(0)  编辑  收藏  举报