详细分析MybatisPlus中的orderBy、orderByDesc、orderByAsc函数

前言

实战中学习并进行补充该类的源码以及应用

1. 概念

在 MyBatis-Plus 中，orderBy、orderByDesc 和 orderByAsc 是用于构建 SQL 查询语句中的 ORDER BY 子句的方法。

这些方法都是通过 QueryWrapper 类的实例来调用的，基础的只是可看我之前的文章：Springboot整合MybatisPlus的基本CRUD（全）

对应的源码如下：（此处的源码来源于Func.java类中）

default Children orderByAsc(R column) {
        return orderByAsc(true, column);
    }

    /**
     * ignore
     */
    default Children orderByAsc(R... columns) {
        return orderByAsc(true, columns);
    }

    /**
     * 排序：ORDER BY 字段, ... ASC
     * 
例: orderByAsc("id", "name")
     *
     * @param condition 执行条件
     * @param columns   字段数组
     * @return children
     */
    default Children orderByAsc(boolean condition, R... columns) {
        return orderBy(condition, true, columns);
    }

    /**
     * ignore
     */
    default Children orderByDesc(R column) {
        return orderByDesc(true, column);
    }

    /**
     * ignore
     */
    default Children orderByDesc(R... columns) {
        return orderByDesc(true, columns);
    }

    /**
     * 排序：ORDER BY 字段, ... DESC
     * 
例: orderByDesc("id", "name")
     *
     * @param condition 执行条件
     * @param columns   字段数组
     * @return children
     */
    default Children orderByDesc(boolean condition, R... columns) {
        return orderBy(condition, false, columns);
    }

    /**
     * 排序：ORDER BY 字段, ...
     * 
例: orderBy(true, "id", "name")
     *
     * @param condition 执行条件
     * @param isAsc     是否是 ASC 排序
     * @param columns   字段数组
     * @return children
     */
    Children orderBy(boolean condition, boolean isAsc, R... columns);

对应的实现类大部分来源于如下：（AbstractWrapper类中）

    @Override
    public Children orderBy(boolean condition, boolean isAsc, R... columns) {
        if (ArrayUtils.isEmpty(columns)) {
            return typedThis;
        }
        SqlKeyword mode = isAsc ? ASC : DESC;
        for (R column : columns) {
            doIt(condition, ORDER_BY, () -> columnToString(column), mode);
        }
        return typedThis;
    }

• 第一个参数：执行条件，是否执行
• 第二个条件：升降序，升序则为ASC，降序为DESC
• 第三个条件：列属性

2. API示例

• orderBy(fieldName):orderBy 方法用于指定按照某个字段进行排序，默认是升序排列。

通过指定字段名，生成 SQL 查询语句中的 ORDER BY 子句，用于排序结果集。

// 示例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderBy("age");

• orderByDesc(fieldName):orderByDesc 方法用于指定按照某个字段进行降序排序。

通过指定字段名，生成 SQL 查询语句中的 ORDER BY 子句，用于降序排序结果集。

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

• orderByAsc(fieldName):orderByAsc 方法用于指定按照某个字段进行升序排序。

通过指定字段名，生成 SQL 查询语句中的 ORDER BY 子句，用于升序排序结果集。

// 示例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age");

这些方法都是用于构建查询条件的 Wrapper 对象，并且可以链式调用。下面是一个简单的示例，展示如何使用这些方法：

// 示例
public class MyBatisPlusExample {
    public static void main(String[] args) {
        // 创建 QueryWrapper 对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        // 添加查询条件
        queryWrapper.eq("gender", "male")
                    .ge("age", 18)
                    .le("age", 30)
                    .orderByDesc("age");

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

        // 处理查询结果
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

在上面的示例中，通过 queryWrapper.orderByDesc(“age”) 方法指定按照年龄字段降序排列结果集。这样，生成的 SQL 查询语句中就会包含 ORDER BY 子句，按照指定的条件排序查询结果。

3. 实战

假设数据表中的数据为：

实体类：

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("test_user1")
public class User1 {
    @TableId(value = "id", type = IdType.AUTO)
    private int id;
    private String username;
    private int age;
    // 其他字段...
}

Mapper类为：

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User1;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper1 extends BaseMapper<User1> {
    // 这里可以自定义一些查询方法
}

service类为：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.demo.entity.User1;

public interface UserService1 extends IService<User1> {
    // 这里可以自定义一些业务方法
}

实现类为：

package com.example.demo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User1;
import com.example.demo.mapper.UserMapper1;
import com.example.demo.service.UserService1;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl1 extends ServiceImpl<UserMapper1, User1> implements UserService1 {
    // 这里可以实现自定义的业务方法
}

---

对应的测试类如下：

• 将多个数据进行排序比较：

    @Test
    public void test16(){
        List<User1> user = userService1.list(new LambdaQueryWrapper<User1>()
                .orderBy(true,false,User1::getAge,User1::getUsername)
        );

        user.forEach(System.out::println);
		// 输出：
		// User1(id=3, username=user1, age=25)
		// User1(id=2, username=user1, age=19)
		// User1(id=4, username=user2, age=18)
		// User1(id=1, username=user1, age=18)

    }

截图如下所示：
（通过截图可以看出具体的顺序是怎样的，这有助于我们实战中的开发抽取某个类别！！请看下面的功能测试）

• 如果有多个数据，可以获取最新一条数据:

    @Test
    public void test16(){
        User1 user = userService1.getOne(new LambdaQueryWrapper<User1>()
                .eq(User1::getUsername,"user1")
                .orderBy(true,false,User1::getAge)
                .last("limit 1")
        );

        System.out.println(user);


    }

截图如下：（抽取最新的一条，从而忽略原先的数据，通过limit 1 加以配合限制）

对于orderByAsc以及orderByDesc，函数最后还是使用了orderBy，原理一致