LambdaQueryWrapper的使用

qq_37834811

已于 2025-01-12 22:05:12 修改

阅读量2.9w

点赞数 52

文章标签： java 开发语言

于 2024-03-01 23:27:28 首次发布

本文链接：https://blog.youkuaiyun.com/qq_37834811/article/details/136405791

版权

文章详细介绍了Mybatis-Plus中LambdaQueryWrapper的各种查询方法，包括基本的等于、不等于、模糊查询、范围查询、排序、分组、条件过滤，以及高级的自定义SQL、嵌套查询等，并展示了如何通过clear方法实现多次条件切换查询。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、常用方法

eq - 等于
用于构造WHERE条件，比较两个值是否相等。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getName, "张三");

ne - 不等于
用于构造WHERE条件，比较两个值是否不等。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.ne(User::getName, "张三");

like - 模糊查询
用于构造模糊查询的WHERE条件。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName, "张");

between - 范围查询
用于构造范围查询的WHERE条件。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.between(User::getAge, 18, 30);

orderByDesc - 降序排序
用于对查询结果进行降序排序。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.orderByDesc(User::getAge);

select - 指定查询字段
用于指定查询的字段，减少返回的数据量。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(User::getId, User::getName);

groupBy - 分组
用于对查询结果进行分组。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.groupBy(User::getAge);

having - 分组条件
用于对分组的结果进行条件过滤。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.groupBy(User::getAge)
            .having("sum(age) > {0}", 100);

or - 或条件
用于构造OR条件。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getName, "张三")
            .or()
            .eq(User::getName, "李四");

isNull - 字段为空
用于检查字段是否为NULL。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.isNull(User::getName);

二、不常用/高级方法

apply - 自定义SQL条件
用于直接注入自定义的SQL条件。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.apply("date_format(create_time,'%Y-%m-%d') = '2020-02-02'");

last - 直接拼接到SQL的最后
用于直接在SQL的最后拼接一段字符串，需要谨慎使用，以免破坏SQL的结构。

LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.last("limit 1");

clear - 方法是用来清空LambdaQueryWrapper中已设置的所有条件，让这个对象可以重新设置条件进行查询。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import your.package.User; // 引入你的实体类

public class Example {
    public static void main(String[] args) {
        // 创建LambdaQueryWrapper实例
        LambdaQueryWrapper<User> queryWrapper = Wrappers.lambdaQuery();
        
        // 为queryWrapper添加查询条件
        queryWrapper.eq(User::getName, "张三");
        
        // 使用queryWrapper进行查询...
        // 这里演示为假定的查询方法，具体使用应替换为实际的查询方法
        List<User> users = yourQueryMethod(queryWrapper);
        System.out.println("第一次查询结果：" + users);
        
        // 使用clear方法清空之前设置的所有条件
        queryWrapper.clear();
        
        // 重新设置查询条件
        queryWrapper.gt(User::getAge, 25);
        
        // 再次使用queryWrapper进行查询...
        // 同样，这里的查询方法需要替换为实际的查询方法
        List<User> newUsers = yourQueryMethod(queryWrapper);
        System.out.println("第二次查询结果：" + newUsers);
    }
    
    // 假定的查询方法，实际使用时应替换为具体的查询逻辑
    private static List<User> yourQueryMethod(LambdaQueryWrapper<User> queryWrapper) {
        // 假定的查询逻辑，应替换为实际查询逻辑
        return new ArrayList<>();
    }
}

在这个例子中，我们首先使用LambdaQueryWrapper设置了一个基于用户名的查询条件（假设是查询名字为“张三”的用户）。然后，通过调用clear方法，清空了LambdaQueryWrapper中的所有条件。之后，我们又为它设置了一个新的条件（年龄大于25岁），并进行了第二次查询。

这样，我们就可以利用clear方法，对同一个LambdaQueryWrapper对象进行多次不同条件的查询，而不需要每次都创建新的实例。

getSqlSelect - 方法用于获取 SQL 查询语句中的 SELECT 部分

mport com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;

public class Main {
    public static void main(String[] args) {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(User::getId, User::getName); // 选择 id 和 name 字段

        String sqlSelect = queryWrapper.getSqlSelect();
        if (StringUtils.isNotBlank(sqlSelect)) {
            System.out.println("SELECT " + sqlSelect + " FROM user");
        } else {
            System.out.println("SELECT * FROM user");
        }
    }
}

在这个示例中，我们创建了一个 LambdaQueryWrapper 对象，并使用 select() 方法选择了 id 和 name 字段。然后，我们调用 getSqlSelect() 方法获取 SELECT 部分的 SQL 语句。最后，我们将生成的 SQL 语句输出到控制台。

notExists方法可以用来构建一个“NOT EXISTS”子查询。在SQL中，“NOT EXISTS”通常用来检查一个子查询是否返回空集，如果子查询返回空集，则条件为真。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.entity.User;
import com.example.entity.Order;

public class Main {
    public static void main(String[] args) {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.notExists(
            LambdaQueryWrapper.<Order>select(true)
                .eq(Order::getUserId, User::getId)
                .lt(Order::getAmount, 1000)
        ); // 用户没有金额小于1000的订单

        // 将生成的 SQL 语句输出到控制台
        System.out.println(queryWrapper.getSqlSegment());
    }
}

allEq - 方法是用来构建等值条件的，可以一次性传入多个条件参数，Mybatis-Plus会自动将这些条件以AND的形式连接起来生成SQL语句。下面是一个具体的使用示例：

假设我们有一个用户表user，它有id、name、email等字段，现在我们想要查询name为"Tom"且email为"tom@example.com"的用户。

首先，你需要创建一个LambdaQueryWrapper实例，然后使用allEq方法传入一个Map，这个Map中包含了你想要查询的字段以及对应的值。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import java.util.HashMap;
import java.util.Map;

public class Example {
    public static void main(String[] args) {
        // 创建一个查询条件构造器的实例
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        
        // 创建一个Map，用来存储要查询的字段和对应的值
        Map<SFunction<User, ?>, Object> params = new HashMap<>();
        params.put(User::getName(), "Tom");
        params.put(User::email, "tom@example.com");

        // 使用allEq方法将条件添加到查询构造器中
        // 注意：这里的字段名是根据实际的实体类属性来命名的，而不是数据库中的列名
        queryWrapper.allEq(params);

        // 接下来，你可以将这个构造器作为参数，执行查询操作
        // 例如：List<User> users = userService.list(queryWrapper);
    }
}

在上面的示例中，allEq方法接收了一个Map<String, Object>作为参数，Map的key是实体类的属性名（注意不是数据库表的列名），value是你想要匹配的值。Mybatis-Plus会根据这个Map生成类似于WHERE name = ‘Tom’ AND email = 'tom@example.com’的SQL条件。

除了接收一个Map之外，allEq还有一些重载方法，支持更灵活的条件设置，例如：

allEq(Map<R, V> params, boolean null2IsNull)：这个重载方法额外接收一个布尔值参数，用来指示Map中的null值是应该转换为SQL的IS NULL条件，还是直接忽略这个条件。
allEq(BiPredicate<R, V> filter, Map<R, V> params)：这个重载方法允许你传入一个过滤器（BiPredicate），你可以在这个过滤器中自定义哪些条件应该被加入到最终的SQL语句中。

nested - 方法是其中的一种用法，它主要用于构造嵌套的查询条件，比如需要在括号内添加 AND 或者 OR 杂糅的条件时很有用。下面是使用 LambdaQueryWrapper 的 nested 方法的一个例子：

假设我们有一个用户表（user），我们需要查询以下条件的用户：（年龄大于20 并且名字中包含"John"）或者（年龄小于50 并且
名字中包含"Jane"）在这个查询中，我们需要使用到嵌套查询，因为我们有两组条件需要用括号分开。使用
LambdaQueryWrapper 来构建这个查询的代码可能如下：

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.example.entity.User;

public class Example {
    public void executeQuery() {
        LambdaQueryWrapper<User> queryWrapper = Wrappers.lambdaQuery();
        
        queryWrapper.nested(i -> i.gt(User::getAge, 20).like(User::getName, "John"))
                    .or(i -> i.lt(User::getAge, 50).like(User::getName, "Jane"));
        
        // 这里假设有一个 mapper 对象是通过 MyBatis-Plus 注入的
        // List<User> users = userMapper.selectList(queryWrapper);
        
        // 输出、处理查询到的用户信息...
    }
}