深入解析MyBatis-Plus LambdaQueryWrapper与QueryWrapper：高效数据查询的秘密

狼魂豹速

于 2024-07-16 10:14:48 发布

阅读量4

点赞数

文章标签： mybatis

原文链接：https://blog.csdn.net/Mrxiao_bo/article/details/133760138

版权

深入解析MyBatis-Plus LambdaQueryWrapper与QueryWrapper：高效数据查询的秘密
前言
第一部分：Lambda表达式基础
第二部分：QueryWrapper与LambdaQueryWrapper区别
第三部分：LambdaQueryWrapper的高级用法
1. 基本条件构建：
2. 多表关联查询：
3. 动态条件构建：
4.mysql函数嵌入
第四部分：QueryWrapper的强大功能
1. 动态SQL构建：
2. 自定义SQL片段构建：
第五部分：性能优化和最佳实践
1. 选择性加载数据：
2. 使用索引：
3. 分页查询：
4. 合理使用缓存：
5. 避免N+1查询问题：
6. 合理使用Lambda表达式和Wrapper：
7. 监控和调优：
前言
高级MyBatis-Plus查询：充分利用Wrapper提升效率的前言

MyBatis-Plus作为一个强大的ORM（对象关系映射）框架，为Java开发人员提供了在数据库操作中更高效的工具和方法。在这篇博客中，我们将深入探讨MyBatis-Plus的高级查询技巧，特别是关于如何充分利用Wrapper来构建复杂查询并提升效率。

数据库查询在许多应用程序中起着至关重要的作用，因此优化查询效率对于提高应用程序性能至关重要。MyBatis-Plus的Wrapper提供了一种强大的工具，可以帮助我们以更直观、更灵活的方式构建复杂的SQL查询，而无需编写繁琐的SQL语句。

在本博客中，我们将从基础开始，逐步深入，探讨Wrapper的各种用法，包括条件构建、复杂查询、子查询、排序和分页等。我们还将提供实际案例和最佳实践，以帮助您更好地理解如何在实际项目中应用这些技巧。

无论您是MyBatis-Plus的初学者还是有经验的开发人员，本博客都将为您提供有关高级查询的宝贵见解。通过充分利用Wrapper，您可以更加高效地构建和执行数据库查询，提高应用程序的性能和可维护性。

让我们开始探索MyBatis-Plus的高级查询功能，并发现如何借助Wrapper工具来优化数据库操作，使您的应用程序更加强大和高效。

第一部分：Lambda表达式基础
Lambda表达式是一种匿名函数，它可以被用作一段可传递的代码。Lambda表达式通常用于简化代码，特别是在函数式编程中，它允许你在不创建具体方法的情况下定义一个函数。在Java中，Lambda表达式的语法是->，它可以替代某些接口的匿名内部类。

在MyBatis-Plus中，Lambda表达式的重要性体现在构建查询条件时。它们提供了一种更加类型安全和直观的方式来构建数据库查询条件，而不需要硬编码SQL语句。通过使用Lambda表达式，你可以创建查询条件的对象，而不是手动编写字符串，这有助于减少SQL注入的风险，提高了代码的可维护性。

下面是一个示例，演示如何使用Lambda表达式来表示查询条件：

假设你有一个实体类User，它代表了数据库中的用户表，包含id、name和age字段。你想要查询年龄大于等于30岁的用户：

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;

public class LambdaExpressionExample {

public static void main(String[] args) {
    // 使用Lambda表达式创建查询条件
    QueryWrapper<User> queryWrapper = Wrappers.<User>lambdaQuery()
            .ge(User::getAge, 30);
    
    // 执行查询
    List<User> userList = userDao.selectList(queryWrapper);
    
    // 输出查询结果
    for (User user : userList) {
        System.out.println(user);
    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
在这个示例中，我们使用了Wrappers.lambdaQuery()来创建一个Lambda查询包装器，然后使用.ge(User::getAge, 30)来表示年龄大于等于30岁的条件。这种方式更加直观和类型安全，不需要编写原始的SQL语句，提高了代码的可读性和可维护性。

总之，Lambda表达式在MyBatis-Plus中的重要性在于它们提供了一种更加直观和类型安全的方式来构建数据库查询条件，从而简化了代码并降低了错误的风险。

第二部分：QueryWrapper与LambdaQueryWrapper区别
QueryWrapper和LambdaQueryWrapper都是MyBatis-Plus中用于构建查询条件的工具，但它们之间存在一些重要的区别：

构建方式：

QueryWrapper：使用字符串表示列名，通过字符串拼接的方式构建查询条件，类似于传统的SQL查询。这种方式灵活但不够类型安全。
LambdaQueryWrapper：使用Lambda表达式表示列名，通过Lambda表达式的方式构建查询条件。这种方式更加类型安全，可以在编译时捕获拼写错误。
类型安全：

QueryWrapper：由于使用字符串表示列名，编译器无法检查列名的正确性，因此存在拼写错误或不合法列名的风险。
LambdaQueryWrapper：使用Lambda表达式，可以在编译时捕获属性和字段名的拼写错误，提高了类型安全性。
可读性：

QueryWrapper：由于使用字符串，查询条件的构建可能不够清晰和直观，可能需要更多的注释来解释查询条件的含义。
LambdaQueryWrapper：Lambda表达式更加直观和清晰，使代码更易于理解，通常不需要额外的注释。
智能提示：

QueryWrapper：不同于一些集成开发环境（IDE）提供的智能提示，因为列名是字符串，难以提供准确的自动完成和错误检查。
LambdaQueryWrapper：常见的IDE通常能够提供Lambda表达式的智能提示，帮助您更快地编写查询条件。
链式操作：

QueryWrapper和LambdaQueryWrapper都支持链式操作，使得构建复杂的查询条件变得更加清晰。
总的来说，LambdaQueryWrapper相对于QueryWrapper更加类型安全、清晰易读，因此在实际开发中，特别是需要在编译时捕获错误和提高代码可维护性的情况下，更常用。但如果您对查询条件的灵活性有更高的要求，QueryWrapper仍然是一个有效的选择，因为它允许您以字符串的形式构建复杂的查询条件。

第三部分：LambdaQueryWrapper的高级用法
LambdaQueryWrapper是MyBatis-Plus中用于构建复杂查询条件的强大工具。它允许你使用Lambda表达式来创建查询条件，包括条件构建和多表关联查询。下面将深入讨论LambdaQueryWrapper的高级用法，并演示如何使用Lambda表达式生成查询条件。

基本条件构建：
首先，让我们看看如何使用LambdaQueryWrapper构建基本查询条件。假设我们有一个名为User的实体类，并且我们想要查询年龄大于30岁且名字包含"John"的用户：

LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery()
.ge(User::getAge, 30)
.like(User::getName, “John”);

List userList = userDao.selectList(queryWrapper);
1
2
3
4
5
在这个示例中，我们使用.ge(User::getAge, 30)表示大于等于30岁的条件，使用.like(User::getName, “John”)表示名字包含"John"的条件。

多表关联查询：
LambdaQueryWrapper还支持多表关联查询。假设我们有一个名为Order的实体类，表示用户的订单，其中包含了用户的userId字段，我们想要查询年龄大于30岁的用户以及他们的订单信息：

LambdaQueryWrapper userWrapper = Wrappers.lambdaQuery()
.ge(User::getAge, 30);

LambdaQueryWrapper orderWrapper = Wrappers.lambdaQuery()
.inSql(Order::getUserId, “SELECT id FROM user”, userWrapper);

List orderList = orderDao.selectList(orderWrapper);
1
2
3
4
5
6
7
在这个示例中，我们首先创建了一个用于用户表的LambdaQueryWrapper，然后创建了一个用于订单表的LambdaQueryWrapper。在订单表的条件中，我们使用了.inSql()方法，允许我们在子查询中使用另一个LambdaQueryWrapper来构建条件，从而实现多表关联查询。

动态条件构建：
LambdaQueryWrapper也支持动态条件构建，你可以根据实际情况添加或删除条件。例如，如果你有一个搜索页面，用户可以选择性地输入查询条件，你可以像这样动态构建查询条件：

LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery();
if (StringUtils.isNotBlank(username)) {
queryWrapper.like(User::getUsername, username);
}
if (minAge != null) {
queryWrapper.ge(User::getAge, minAge);
}
if (maxAge != null) {
queryWrapper.le(User::getAge, maxAge);
}

List userList = userDao.selectList(queryWrapper);
1
2
3
4
5
6
7
8
9
10
11
12
在这个示例中，根据用户输入的条件，我们动态地添加了.like()、.ge()和.le()等条件，从而构建了查询条件。

总之，LambdaQueryWrapper是一个强大的工具，允许你使用Lambda表达式来构建复杂的查询条件，包括基本条件构建、多表关联查询和动态条件构建。这种方式使得查询条件的构建更加直观和灵活，提高了代码的可读性和可维护性。

4.mysql函数嵌入
假设你有一个实体类User，其中包含了一个日期字段birthDate，你想要查询生日在特定月份的用户，并将生日格式化为"yyyy-MM-dd"格式：

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;

import java.time.format.DateTimeFormatter;

public class LambdaQueryWrapperWithMySQLFunction {

public static void main(String[] args) {
    // 选择要查询的月份，这里假设选择1月
    int selectedMonth = 1;

    LambdaQueryWrapper<User> queryWrapper = Wrappers.<User>lambdaQuery()
            .apply("MONTH(birth_date) = {0}", selectedMonth)
            .select(User::getId, User::getName, User::getBirthDate);

    List<User> userList = userDao.selectList(queryWrapper);
    
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    for (User user : userList) {
        String formattedBirthDate = user.getBirthDate().format(formatter);
        System.out.println("User ID: " + user.getId() + ", Name: " + user.getName() + ", Formatted Birth Date: " + formattedBirthDate);
    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
在这个示例中，我们使用.apply()方法来嵌入MySQL的MONTH()函数，以检查生日的月份是否与selectedMonth匹配。同时，我们使用.select()方法选择要查询的字段，然后在结果中格式化日期字段为"yyyy-MM-dd"格式。

这样，你就可以在LambdaQueryWrapper中使用MySQL的函数来构建查询条件，满足不同的查询需求。根据需要，你可以嵌入其他MySQL函数来执行各种数据库操作。

第四部分：QueryWrapper的强大功能
QueryWrapper是MyBatis-Plus中用于构建查询条件的强大工具，它提供了一些高级功能，包括动态SQL和自定义SQL片段的构建。下面将介绍QueryWrapper的这些高级功能，并提供示例演示如何使用它们来满足特殊的查询需求。

动态SQL构建：
动态SQL允许你根据不同的条件动态构建SQL语句，以满足不同的查询需求。MyBatis-Plus的QueryWrapper通过方法链的方式支持动态SQL构建。例如，假设我们有一个搜索页面，用户可以选择性地输入查询条件，你可以像这样动态构建查询条件：

QueryWrapper queryWrapper = new QueryWrapper<>();
if (StringUtils.isNotBlank(username)) {
queryWrapper.like(“username”, username);
}
if (minAge != null) {
queryWrapper.ge(“age”, minAge);
}
if (maxAge != null) {
queryWrapper.le(“age”, maxAge);
}

List userList = userDao.selectList(queryWrapper);
1
2
3
4
5
6
7
8
9
10
11
12
在这个示例中，根据用户输入的条件，我们动态地添加了.like()、.ge()和.le()等条件，从而构建了查询条件。这使得查询条件可以根据不同的情况进行动态调整，非常灵活。

自定义SQL片段构建：
有时候，你可能需要构建复杂的查询条件，而标准的查询方法不足以满足需求。在这种情况下，你可以使用自定义SQL片段来构建查询条件。例如，如果你需要使用OR条件连接多个子条件，你可以这样做：

QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.or(qw -> qw.like(“username”, “Alice”).or().like(“username”, “Bob”));

List userList = userDao.selectList(queryWrapper);
1
2
3
4
在这个示例中，我们使用了.or(qw -> …)来构建自定义的OR条件，然后在其中使用多个.like()条件。这样就创建了一个查询条件，要么用户名包含"Alice"要么包含"Bob"的用户。

如果你需要构建更复杂的自定义SQL片段，你可以使用apply()方法。例如，如果你需要使用特殊的SQL函数或条件，你可以这样做：

QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.apply(“function_name({0}) = {1}”, “column_name”, value);

List userList = userDao.selectList(queryWrapper);
1
2
3
4
在这个示例中，我们使用了.apply()方法来构建自定义的SQL片段，可以包含特殊的SQL函数和参数。

总之，QueryWrapper提供了强大的功能，包括动态SQL构建和自定义SQL片段，使得你可以根据不同的查询需求灵活构建复杂的查询条件。这种灵活性和可扩展性有助于应对各种复杂的数据库查询场景。

第五部分：性能优化和最佳实践
性能优化是数据库查询中非常重要的一部分，以下是一些关于如何避免不必要的数据库查询和提高查询效率的建议，以及如何合理使用Lambda表达式和Wrapper来获得最佳性能的最佳实践。

选择性加载数据：
避免不必要的数据加载是提高查询性能的关键。在查询时，只选择那些你实际需要的字段，而不是加载整个实体对象。使用select方法来指定要查询的字段，以减少数据传输和内存占用。

LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery()
.select(User::getId, User::getName)
.eq(User::getStatus, 1);

List userList = userDao.selectList(queryWrapper);
1
2
3
4
5
2. 使用索引：
确保数据库表中的查询字段都有适当的索引，以加速查询操作。索引可以大大减少查询的时间复杂度。请与数据库管理员一起工作，确保表的设计和索引的创建是有效的。

分页查询：
如果查询结果集很大，使用分页查询来限制返回的数据量。MyBatis-Plus提供了分页查询的支持，可以使用Page类来进行分页操作。

Page page = new Page<>(1, 10); // 从第一页开始，每页显示10条记录
LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery()
.eq(User::getStatus, 1);

IPage userPage = userDao.selectPage(page, queryWrapper);
1
2
3
4
5
4. 合理使用缓存：
数据库查询的结果可以被缓存，以避免频繁的数据库访问。可以使用缓存框架如Redis或Memcached来实现查询结果的缓存，以减少数据库负载。

避免N+1查询问题：
当需要查询关联实体时，避免N+1查询问题，即查询主实体后再单独查询关联实体。使用selectJoin方法或者leftJoin等方法来一次性加载关联实体的数据，而不是在循环中进行多次查询。
合理使用Lambda表达式和Wrapper：
使用Lambda表达式和Wrapper来构建查询条件，可以提高代码的可读性和可维护性。
避免在循环中创建大量的Wrapper对象，尽量复用已创建的对象，以减少内存消耗。
对于复杂查询，可以使用apply方法嵌入原生SQL条件，但要小心SQL注入问题。
注意使用select方法来选择需要的字段，以减少不必要的数据传输。
监控和调优：
定期监控数据库性能，并进行必要的调优。使用数据库性能分析工具，如Explain命令，来查看查询执行计划，并根据需要进行索引优化和SQL语句优化。

总之，性能优化是数据库应用程序开发的重要部分。避免不必要的数据库查询、合理使用Lambda表达式和Wrapper、选择性加载数据以及使用合适的索引和缓存等方法都可以显著提高查询性能。在项目开发中，要根据具体情况采取不同的优化策略，以确保应用程序的性能达到最佳水平。
————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/Mrxiao_bo/article/details/133760138深入解析MyBatis-Plus LambdaQueryWrapper与QueryWrapper：高效数据查询的秘密
前言
第一部分：Lambda表达式基础
第二部分：QueryWrapper与LambdaQueryWrapper区别
第三部分：LambdaQueryWrapper的高级用法
1. 基本条件构建：
2. 多表关联查询：
3. 动态条件构建：
4.mysql函数嵌入
第四部分：QueryWrapper的强大功能
1. 动态SQL构建：
2. 自定义SQL片段构建：
第五部分：性能优化和最佳实践
1. 选择性加载数据：
2. 使用索引：
3. 分页查询：
4. 合理使用缓存：
5. 避免N+1查询问题：
6. 合理使用Lambda表达式和Wrapper：
7. 监控和调优：
前言
高级MyBatis-Plus查询：充分利用Wrapper提升效率的前言