Mybatis-plus-SimpleQuery

本文与官网大多数一致，只是在示例中加入了一些实际验证的代码，日志可能和与官网略有出入（预估是因为版本原因）

本文测试代码中mybatis-plus依赖:


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

SimpleQuery 是 Mybatis-Plus 提供的一个工具类，它对 selectList 查询后的结果进行了封装，使其可以通过 Stream 流的方式进行处理，从而简化了 API 的调用。

SimpleQuery 的一个特点是它的 peeks 参数，这是一个可变参数，类型为 Consumer...，意味着你可以连续添加多个操作，这些操作会在查询结果被处理时依次执行。

注：使用 SimpleQuery 前，需要确保项目中已注入对应实体的 BaseMapper。

常用函数

keyMap

keyMap函数签名

SimpleQuery 的 keyMap 方法提供了一种便捷的方式来查询数据库，并将查询结果封装成一个 Map，其中实体的某个属性作为键（key），实体本身作为值（value）。这个方法还支持在处理查询结果时执行额外的副作用操作，如打印日志或更新缓存。

public static <E, A> Map<A, E> keyMap(LambdaQueryWrapper<E> wrapper, SFunction<E, A> sFunction, Consumer<E>... peeks)
public static <E, A> Map<A, E> keyMap(LambdaQueryWrapper<E> wrapper, SFunction<E, A> sFunction, boolean isParallel, Consumer<E>... peeks)

keyMap参数说明

类型	参数名	描述
E	entity	实体对象类型，即查询结果的实体类型。
A	attribute	实体属性类型，也是返回的 Map 中键（key）的类型。
LambdaQueryWrapper<E>	wrapper	支持 lambda 表达式的条件构造器，用于构建查询条件。
SFunction<E, A>	sFunction	实体中属性的 getter 方法引用，用于确定 Map 中键（key）的值。
boolean	isParallel	如果设置为 true，则底层使用并行流执行查询，可以提高处理大量数据时的效率。
Consumer<E>…	peeks	可变参数，用于指定在处理查询结果时执行的额外操作，如打印日志、更新缓存等。

map

SimpleQuery 的 map 方法提供了一种便捷的方式来查询数据库，并将查询结果封装成一个 Map，其中实体的某个属性作为键（key），另一个属性作为值（value）。这个方法还支持在处理查询结果时执行额外的副作用操作，如打印日志或更新缓存。

map函数签名

public static <E, A, P> Map<A, P> map(LambdaQueryWrapper<E> wrapper, SFunction<E, A> keyFunc, SFunction<E, P> valueFunc, Consumer<E>... peeks)
public static <E, A, P> Map<A, P> map(LambdaQueryWrapper<E> wrapper, SFunction<E, A> keyFunc, SFunction<E, P> valueFunc, boolean isParallel, Consumer<E>... peeks)

map参数说明

类型	参数名	描述
E	entity	实体对象类型，即查询结果的实体类型。
A	attribute	实体属性类型，作为返回的 Map 中键（key）的类型。
P	attribute	实体属性类型，作为返回的 Map 中值（value）的类型。
LambdaQueryWrapper<E>	wrapper	支持 lambda 表达式的条件构造器，用于构建查询条件。
SFunction<E, A>	keyFunc	实体中属性的 getter 方法引用，用于确定 Map 中键（key）的值。
SFunction<E, P>	valueFunc	实体中属性的 getter 方法引用，用于确定 Map 中值（value）的值。
boolean	isParallel	如果设置为 true，则底层使用并行流执行查询，可以提高处理大量数据时的效率。
Consumer<E>…	peeks	可变参数，用于指定在处理查询结果时执行的额外操作，如打印日志、更新缓存等。

group

SimpleQuery 的 group 方法提供了一种便捷的方式来查询数据库，并将查询结果按照实体的某个属性进行分组，封装成一个 Map。这个方法还支持在处理查询结果时执行额外的副作用操作，如打印日志或更新缓存。此外，它还允许你使用 Collector 对分组后的集合进行进一步的处理。

group函数签名

public static <E, A> Map<A, List<E>> group(LambdaQueryWrapper<E> wrapper, SFunction<E, A> sFunction, Consumer<E>... peeks)
public static <T, K> Map<K, List<T>> group(LambdaQueryWrapper<T> wrapper, SFunction<T, K> sFunction, boolean isParallel, Consumer<T>... peeks)
public static <T, K, D, A> Map<K, D> group(LambdaQueryWrapper<T> wrapper, SFunction<T, K> sFunction, Collector<T, A, D> downstream, Consumer<T>... peeks)
public static <T, K, D, A> Map<K, D> group(LambdaQueryWrapper<T> wrapper, SFunction<T, K> sFunction, Collector<T, A, D> downstream, boolean isParallel, Consumer<T>... peeks)

group参数说明

类型	参数名	描述
T	entity	实体对象类型，即查询结果的实体类型。
K	attribute	实体属性类型，作为返回的 Map 中键（key）的类型。
D	-	下游收集器返回类型，作为 Map 中值（value）的类型。
A	-	下游操作中间类型，用于 Collector 的中间结果。
M	-	最终结束返回的 Map<K, D> 类型。
LambdaQueryWrapper<T>	wrapper	支持 lambda 表达式的条件构造器，用于构建查询条件。
SFunction<T, K>	sFunction	分组依据，实体中属性的 getter 方法引用，用于确定 Map 中键（key）的值。
Collector<T, A, D>	downstream	下游收集器，用于对分组后的集合进行进一步的处理。
boolean	isParallel	如果设置为 true，则底层使用并行流执行查询，可以提高处理大量数据时的效率。
Consumer<T>…	peeks	可变参数，用于指定在处理查询结果时执行的额外操作，如打印日志、更新缓存等。

list

list函数签名

public static <E, A> List<A> list(LambdaQueryWrapper<E> wrapper, SFunction<E, A> sFunction, Consumer<E>... peeks)
public static <E, A> List<A> list(LambdaQueryWrapper<E> wrapper, SFunction<E, A> sFunction, boolean isParallel, Consumer<E>... peeks)

list参数说明

SimpleQuery 的 list 方法提供了一种便捷的方式来查询数据库，并将查询结果封装成一个 List，其中列表的元素是实体的某个属性。这个方法还支持在处理查询结果时执行额外的副作用操作，如打印日志或更新缓存。

类型	参数名	描述
E	entity	实体对象类型，即查询结果的实体类型。
A	attribute	实体属性类型，作为返回的 List 中元素的类型。
LambdaQueryWrapper<E>	wrapper	支持 lambda 表达式的条件构造器，用于构建查询条件。
SFunction<E, A>	sFunction	实体中属性的 getter 方法引用，用于确定 List 中元素的值。
boolean	isParallel	如果设置为 true，则底层使用并行流执行查询，可以提高处理大量数据时的效率。
Consumer<E>…	peeks	可变参数，用于指定在处理查询结果时执行的额外操作，如打印日志、更新缓存等。

使用示例

    /*************************************************************************/
    //执行一个检查的查询
    @Test
    public void testKeyMap1() {
        Map<Integer, PurchaseOrderPo> integerPurchaseOrderPoMap = SimpleQuery.keyMap(
                Wrappers.lambdaQuery(PurchaseOrderPo.class), // 使用 lambda 查询构建器
                PurchaseOrderPo::getId// 提取的字段，这里是 User 的 id
        );
        log.info("integerPurchaseOrderPoMap:{}",integerPurchaseOrderPoMap);
    }
    // ==>  Preparing: SELECT id,username,state,create_time,update_time FROM purchase_order
    // ==> Parameters: 
    //这里我只写了sql日志，查询结果比较多。这里就不在写了
    //返回结果是一个map key是PurchaseOrderPo::getId的值（也就是主键ID）,Value是PurchaseOrderPo
    

    /*************************************************************************/
    //执行一个简单查询，并打印日志
    @Test
    public void testKeyMap2() {
        Map<Integer, PurchaseOrderPo> integerPurchaseOrderPoMap = SimpleQuery.keyMap(
                Wrappers.lambdaQuery(PurchaseOrderPo.class), // 使用 lambda 查询构建器
                PurchaseOrderPo::getId,// 提取的字段，这里是 User 的 id
                System.out::println
        );
    }

    // ==>  Preparing: SELECT id,username,state,create_time,update_time FROM purchase_order
    // ==> Parameters: 
    // <==    Columns: id, username, state, create_time, update_time
    // <==        Row: 3, 王五, 0, null, 03:21:36
    // <==        Row: 4, 王小红, 1, null, null
    // <==        Row: 5, 王麻子, 1, null, null
    // <==        Row: 6, 李小雨, 2, null, null
    // <==        Row: 9, 王二狗, 1, 03:04:21, 03:04:21
    // <==      Total: 5
    // Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7eefaca0]
    // PurchaseOrderPo(id=3, username=王五, state=0, createTime=null, updateTime=Thu Jan 01 03:21:36 CST 1970)
    // PurchaseOrderPo(id=4, username=王小红, state=1, createTime=null, updateTime=null)
    // PurchaseOrderPo(id=5, username=王麻子, state=1, createTime=null, updateTime=null)
    // PurchaseOrderPo(id=6, username=李小雨, state=2, createTime=null, updateTime=null)
    // ...
    //这里使用 System.out::println答应了每一行内容


    /*************************************************************************/
    @Test
    public void testMap1() {
        Map<String, Date> map = SimpleQuery.map(
                Wrappers.lambdaQuery(PurchaseOrderPo.class).eq(PurchaseOrderPo::getState,0), // 使用 lambda 查询构建器
                PurchaseOrderPo::getUsername,// 提取的字段，这里是 User 的 id
                PurchaseOrderPo::getCreateTime,
                System.out::println
        );
    }


    // ==>  Preparing: SELECT id,username,state,create_time,update_time FROM purchase_order WHERE (state = ?)
    // ==> Parameters: 0(Integer)
    // <==    Columns: id, username, state, create_time, update_time
    // <==        Row: 3, 王五, 0, null, 03:21:36
    // <==      Total: 1

    // 这个函数中使用Wrappers.lambdaQuery(PurchaseOrderPo.class).eq(PurchaseOrderPo::getState,0)过滤
    //返回的map中PurchaseOrderPo::getUsername的结果为key，PurchaseOrderPo::getCreateTime结果为value
    //打印了查询的结果

    /*************************************************************************/
    @Test
    public void testGroup1() {
        Map<Integer, List<PurchaseOrderPo>> group = SimpleQuery.group(
                Wrappers.lambdaQuery(PurchaseOrderPo.class), // 使用 lambda 查询构建器
                PurchaseOrderPo::getState,// 提取的字段，这里是 User 的 id
                System.out::println
        );
    }

    // ==>  Preparing: SELECT id,username,state,create_time,update_time FROM purchase_order
    // ==> Parameters: 
    // <==    Columns: id, username, state, create_time, update_time
    // <==        Row: 3, 王五, 0, null, 03:21:36
    // <==        Row: 4, 王小红, 1, null, null
    // ···
    //这里返回的Map key是PurchaseOrderPo::getState值，value是PurchaseOrderPo

     /*************************************************************************/
    @Test
    public void testList1() {
        List<String> usernames = SimpleQuery.list(
                Wrappers.lambdaQuery(PurchaseOrderPo.class), // 使用 lambda 查询构建器
                PurchaseOrderPo::getUsername,
                System.out::println
        );
        log.info("usernames:{}",usernames);
    }
    // ==>  Preparing: SELECT id,username,state,create_time,update_time FROM purchase_order
    // ==> Parameters: 
    // <==    Columns: id, username, state, create_time, update_time
    // <==        Row: 3, 王五, 0, null, 03:21:36
    // <==        Row: 4, 王小红, 1, null, null
    // <==        Row: 5, 王麻子, 1, null, null
    //....
    //这里返回的List中值是PurchaseOrderPo::getUsername中的

可以看出上面接个函数转换出来的sql都基本一样，主要是对查询到的结果进行了的二次操作封装

目录CONTENT

mybatis-plus-SimpleQuery