常用的工具类

前言

总结记录一下在开发中经常使用到的一些工具类。

MD5加密

用户的密码一般都会进行加密后在存储到数据库当中，所以一般用到MD5这种加密算法。

这种加密算法最大的特点就是不可逆，只能加密不能解密。

这是挺简单的一种加密算法了，之后还可以考虑加盐和哈希散列，进行更复杂的加密手段。

public class Md5Utils {
    public static String encrypt(String strSrc) {
        try {
            char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            byte[] bytes = strSrc.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (int i = 0; i < bytes.length; i++) {
                byte b = bytes[i];
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错+" + e);
        }
    }
}

雪花算法

对于MySQL的主键问题，一般都需要使用自增的主键。但是只是从1自增就会因为分库分表产生主键相同的情况。

所以这次使用雪花算法生成一个分布式全局唯一ID

首先要知道雪花算法生成的ID是怎么样的。

分布式ID一般都是Long类型，所以会有64位。

• 第一部分是一个bit位，是一个标识部分，在java中由于long的最高位是符号位，正数是0，负数是1，一般生成的ID为正数，所以固定为0
• 第二部分是时间戳，该部分占41bit，这个是毫秒级的时间
• 第三部分是工作机器ID，占10bit
• 第四部分是序列号，占12bit，支持同一毫秒内同一个节点可以生成4096个ID

/**
 * <p>
 *     雪花算法，分布式全局唯一ID
 * </p>
 * @ClassName SnowFlake
 * @Author yww
 * @date 2021/4/24 18:39
 **/
public class SnowFlake {

    /**
     *  起始的时间戳
     */
    private final static long START_STMP = 1480166465631L;
    /**
     *  序列号占用的位数
     */
    private final static long SEQUENCE_BIT = 12;
    /**
     *  机器标识占用的位数
     */
    private final static long MACHINE_BIT = 5;
    /**
     *  数据中心占用的位数
     */
    private final static long DATACENTER_BIT = 5;
    /**
     *  每一部分的最大值
     */
    private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
    private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
    /**
     *  每一部分向左的位移
     */
    private final static long MACHINE_LEFT = SEQUENCE_BIT;
    private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
    private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;
    /**
     *  数据中心
     */
    private long datacenterId;
    /**
     *  机器标识
     */
    private long machineId;
    /**
     *  序列号
     */
    private long sequence = 0L;
    /**
     *  上一次时间戳
     */
    private long lastStmp = -1L;

    public SnowFlake(long datacenterId, long machineId) {
        if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
            throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
        }
        if (machineId > MAX_MACHINE_NUM || machineId < 0) {
            throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
        }
        this.datacenterId = datacenterId;
        this.machineId = machineId;
    }

    /**
     *  产生下一个ID
     */
    public synchronized long nextId() {
        long currStmp = getNewstmp();
        if (currStmp < lastStmp) {
            throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
        }

        if (currStmp == lastStmp) {
            //相同毫秒内，序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            //同一毫秒的序列数已经达到最大
            if (sequence == 0L) {
                currStmp = getNextMill();
            }
        } else {
            //不同毫秒内，序列号置为0
            sequence = 0L;
        }

        lastStmp = currStmp;

        return          // 时间戳部分
                (currStmp - START_STMP) << TIMESTMP_LEFT
                        // 数据中心部分
                | datacenterId << DATACENTER_LEFT
                        // 机器标识部分
                | machineId << MACHINE_LEFT
                        // 序列号部分
                | sequence;
    }

    private long getNextMill() {
        long mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }

    private long getNewstmp() {
        return System.currentTimeMillis();
    }

    /**
     *  测试
     */
    public static void main(String[] args) {

        SnowFlake snowFlake = new SnowFlake(2, 3);

        for (int i = 0; i < (1 << 12); i++) {
            System.out.println(snowFlake.nextId());
        }

    }


}

参考于:https://github.com/beyondfengyu/SnowFlake

JWT工具类

引入依赖

<!--  jwt  -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>${jwt.version}</version>
</dependency>

工具类

package com.yww.management.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.*;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 *      Token工具类
 * 1. Header,记录令牌类型和签名算法
 * 2. payload,携带用户信息
 *      (1) iss(issuer), 签发者
 *      (2) sub(subject), 面向的主体
 *      (3) aud(audience), 接收方
 *      (4) nbf(notBefore), 开始生效生效时间戳
 *      (5) exp(expiresAt), 过期时间戳
 *      (6) iat(issuedAt ), 签发时间
 *      (7) jti(jwtId), 唯一标识
 * 3. signature, 签名，防止Token被篡改
 * </p>
 *
 * @ClassName TokenUtil
 * @Author yww
 * @Date 2022/10/15 14:31
 */
public class TokenUtil {

    /**
     * 生成Token
     *
     * @return  Token
     */
    public static String genToken(String secret) {
        // 设置Token头部（不设置也会默认有这两个值）
        Map<String, Object> header = new HashMap<String, Object>(2) {
            private static final long serialVersionUID = 1L;
            {
                put("alg", "HMAC512");
                put("typ", "JWT");
            }
        };
        // 设置需要放在Token的有效载荷
        Map<String, Object> payload = new HashMap<String, Object>(3) {
            private static final long serialVersionUID = 1L;
            {
                put("name", "yww");
                put("num", 1141950370);
            }
        };

        Date now = new Date();
        Date exp = new Date(now.getTime() + 10);

        return JWT.create()
                // 设置header
                .withHeader(header)
                // 设置payload
                .withIssuer("yww")
                .withSubject("management")
                .withAudience("vue-management")
                .withNotBefore(now)
                .withExpiresAt(exp)
                .withIssuedAt(now)
                .withJWTId("123456")
                .withPayload(payload)
                // 签名
                .sign(Algorithm.HMAC512(secret));
    }

    /**
     * 解析Token
     *
     * @param token Token
     */
    public static void parse(String token) {
        try {
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC512("1")).build();
            DecodedJWT decode = jwtVerifier.verify(token);
            System.out.println(decode.getHeader());
            System.out.println(decode.getPayload());
            System.out.println(decode.getSignature());
        } catch (AlgorithmMismatchException e) {
            System.out.println("签名算法不匹配");
        } catch (SignatureVerificationException e) {
            System.out.println("签名无效");
        } catch (TokenExpiredException e) {
            System.out.println("令牌已过期");
        } catch (MissingClaimException e) {
            System.out.println("缺少要验证的声明");
        } catch (IncorrectClaimException e) {
            System.out.println("声明包含的值和预期不符合");
        } catch (JWTVerificationException e) {
            System.out.println("验证中的某一个步骤失败");
        }
    }

}

响应工具类

import cn.hutool.json.JSONUtil;
import com.yww.management.common.Result;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * <p>
 *      用于接口外响应JSON的响应工具类
 * </p>
 *
 * @ClassName ResponseUtil
 * @Author yww
 * @Date 2022/10/12 21:30
 */
public class ResponseUtil {

    /**
     * 用于返回JSON数据
     * @param response 请求响应
     * @param result   响应封装
     */
    public static void response(HttpServletResponse response, Result<Object> result) throws IOException {
        // 设置响应的Header
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control","no-cache");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        // 设置响应码
        response.setStatus(result.getCode());
        // 设置响应内容
        response.getWriter().write(JSONUtil.toJsonStr(result));
        // 将缓存信息刷新到页面
        response.getWriter().flush();
    }

}

IP工具类

这个工具类主要是用于获取请求的IP地址。

import cn.hutool.core.util.StrUtil;

import javax.servlet.http.HttpServletRequest;

/**
 * <p>
 *      IP相关工具类
 * </p>
 *
 * @ClassName IpUtil
 * @Author yww
 * @Date 2022/10/16 14:27
 */
public class IpUtil {

    /**
     * 获取客户端IP
     *
     * @param request   请求
     * @return          IP
     */
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        }
        // 判断x-forwarded-for是否有IP
        String ip = request.getHeader("x-forwarded-for");
        if (isNotUnknown(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        // 判断Proxy-Client-IP是否有IP
        if (isNotUnknown(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }
        // 判断X-Forwarded-For是否有IP
        if (isNotUnknown(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        // 判断WL-Proxy-Client-IP是否有IP
        if (isNotUnknown(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        // 判断X-Real-IP是否有IP
        if (isNotUnknown(ip)) {
            ip = request.getRemoteAddr();
        }
        // 若是IP最后为0:0:0:0:0:0:0:1，就是本地回环地址，否则第一个非unknown的IP地址就是真实地址
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
    }

    /**
     * 从多级反向代理中获得第一个非unknown IP地址
     *
     * @param ip 获得的IP地址
     * @return 第一个非unknown IP地址
     */
    @SuppressWarnings("all")
    public static String getMultistageReverseProxyIp(String ip) {
        // 多级反向代理检测
        if (ip != null && ip.indexOf(",") > 0) {
            final String[] ips = ip.trim().split(",");
            for (String subIp : ips) {
                if (isNotUnknown(subIp)) {
                    ip = subIp;
                    break;
                }
            }
        }
        return ip;
    }

    /**
     * 检测给定字符串是否为未知，多用于检测HTTP请求相关
     *
     * @param checkString 被检测的字符串
     * @return 是否未知
     */
    public static boolean isNotUnknown(String checkString) {
        return StrUtil.isNotBlank(checkString) && StrUtil.isNotEmpty(checkString) && !"unknown".equalsIgnoreCase(checkString);
    }

}

BigDecimal工具类

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * <p>
 *      BigDecimal工具类
 *  用来提供浮点数的精确运算的工具类
 * </p>
 *
 * @ClassName BigDecimalUtil
 * @Author yww
 * @Date 2022/10/25 16:47
 */
public class BigDecimalUtil {

    /**
     *  除法运算默认精度
     */
    private static final int DEFAULT_PRECISION = 10;

    /**
     *  私有化无参构造
     */
    private BigDecimalUtil() {}

    /**
     *  用于浮点数的精确加法
     *
     * @param value1    浮点数1
     * @param value2    浮点数2
     * @return          浮点数1 + 浮点数2
     */
    public static double addUp(double value1, double value2) {
        BigDecimal b1 = BigDecimal.valueOf(value1);
        BigDecimal b2 = BigDecimal.valueOf(value2);
        return b1.add(b2).doubleValue();
    }

    /**
     *  精确减法
     *
     * @param value1    浮点数1
     * @param value2    浮点数2
     * @return          浮点数1 - 浮点数2
     */
    public static double subtract(double value1, double value2) {
        BigDecimal b1 = BigDecimal.valueOf(value1);
        BigDecimal b2 = BigDecimal.valueOf(value2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     *  精确乘法
     *
     * @param value1    浮点数1
     * @param value2    浮点数2
     * @return          浮点数1 * 浮点数2
     */
    public static double multiply(double value1, double value2) {
        BigDecimal b1 = BigDecimal.valueOf(value1);
        BigDecimal b2 = BigDecimal.valueOf(value2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     *  精确除法(使用默认精度)
     *
     * @param value1    浮点数1
     * @param value2    浮点数2
     * @return          浮点数1 / 浮点数2
     */
    public static double div(double value1, double value2) throws IllegalAccessException {
        return div(value1, value2, DEFAULT_PRECISION);
    }

    /**
     *  精确除法(指定精度)
     *  四舍五入
     *
     * @param value1        浮点数1
     * @param value2        浮点数2
     * @param precision     精度
     * @return              浮点数1 / 浮点数2
     */
    public static double div(double value1, double value2, int precision) throws IllegalAccessException {
        if (precision < 0) {
            throw new IllegalAccessException("除法的精度不能小于0");
        }
        return div(value1, value2, precision, RoundingMode.HALF_UP);
    }

    /**
     *  精确除法(指定精度)
     *  指定舍入的策略
     *
     * @param value1        浮点数1
     * @param value2        浮点数2
     * @param precision     精度
     * @param mode          舍入策略
     * @return              浮点数1 / 浮点数2
     */
    public static double div(double value1, double value2, int precision, RoundingMode mode) throws IllegalAccessException {
        if (precision < 0) {
            throw new IllegalAccessException("除法的精度不能小于0");
        }
        BigDecimal b1 = BigDecimal.valueOf(value1);
        BigDecimal b2 = BigDecimal.valueOf(value2);
        return b1.divide(b2, precision, mode).doubleValue();
    }
    
}

断言工具类

hutool里也有很多断言的工具类，但是抛出的异常不是自己定义的，所以为了指定抛出的异常，需要自己在定义一个断言工具类。

import cn.hutool.core.util.StrUtil;
import com.yww.management.common.exception.GlobalException;

/**
 * <p>
 *      断言工具类
 * </p>
 *
 * @ClassName AssertUtils
 * @Author yww
 * @Date 2022/10/20 11:27
 */
public class AssertUtils {

    /**
     * 私有化无参构造器
     */
    private AssertUtils() {}

    /**
     * 如果对象为{@code null}, 则抛出异常
     *
     * @param object 要判断的对象
     * @throws GlobalException  全局异常类
     */
    public static void notNull(Object object) throws GlobalException {
        notNull(object, "不能处理空对象");
    }

    /**
     * 如果对象为{@code null}, 则抛出异常
     *
     * @param object  要判断的对象
     * @param message 断言失败时的错误信息
     * @throws GlobalException  全局异常类
     */
    public static void notNull(Object object, String message) throws GlobalException {
        if (object == null) {
            throw new GlobalException(message);
        }
    }

    /**
     * 如果字符串为{@code null}、空字符串或仅包含空白字符, 则抛出异常
     *
     * @param text 要进行检查的字符串
     * @throws GlobalException  全局异常类
     */
    public static void hasText(String text) throws GlobalException {
        hasText(text, "此参数不能为空字符串");
    }

    /**
     * 如果字符串为{@code null}、空字符串或仅包含空白字符, 则抛出异常
     *
     * @param text    要进行检查的字符串
     * @param message 断言失败时的错误信息
     * @throws GlobalException  全局异常类
     */
    public static void hasText(String text, String message) throws GlobalException {
        if (StrUtil.isBlank(text)) {
            throw new GlobalException(message);
        }
    }
    
}

ThreadLocal工具类

import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 *      ThreadLocal工具类
 * </p>
 *
 * @ClassName ThreadLocalUtil
 * @Author yww
 * @Date 2022/10/21 14:27
 */
@SuppressWarnings("unchecked")
public class ThreadLocalUtil {

    /**
     *  ThreadLocalMap
     */
    private static final ThreadLocal<Map<String, Object>> THREAD_LOCAL_MAP = ThreadLocal.withInitial(HashMap::new);

    /**
     * 私有化无参构造器
     */
    private ThreadLocalUtil() {}

    /**
     * 根据指定的key获取当前线程相关的变量值
     *
     * @param key 变量的key
     * @param <T> 变量值的具体类型
     * @return 若无此key对应的变量值, 则返回{@code null}
     * @throws ClassCastException 若接收此返回值的变量类型与上下文保存的值的实际类型不匹配, 则抛出异常
     */
    public static <T> T get(String key) {
        return (T) THREAD_LOCAL_MAP.get().get(key);
    }

    /**
     * 根据指定的key获取当前线程相关的变量值, 若为{@code null}则返回指定的默认值
     *
     * @param key          变量的key
     * @param defaultValue 默认值
     * @param <T>          变量值的具体类型
     * @return 若无此key对应的变量值, 则返回defaultValue
     * @throws ClassCastException 若接收此返回值的变量类型与上下文保存的值的实际类型不匹配, 则抛出异常
     */
    public static <T> T get(String key, T defaultValue) {
        T value = get(key);
        return value == null ? defaultValue : value;
    }

    /**
     * 设置线程相关上下文的变量值
     *
     * @param key   变量的key
     * @param value 变量值
     */
    public static void set(String key, Object value) {
        THREAD_LOCAL_MAP.get().put(key, value);
    }

    /**
     * 删除指定key的变量
     *
     * @param key 变量的key
     */
    public static void remove(String key) {
        THREAD_LOCAL_MAP.get().remove(key);
    }

    /**
     * 清除当前线程相关的上下文
     */
    public static void close() {
        THREAD_LOCAL_MAP.remove();
    }

}

分页工具类

封装分页请求对象

如果需要添加其他的属性筛选，只需要继承该封装对象即可。

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

/**
 * <p>
 *      分页查询请求对象
 * </p>
 *
 * @ClassName PageVo
 * @Author yww
 * @Date 2022/10/24 21:18
 */
@SuppressWarnings("all")
@JsonIgnoreProperties(ignoreUnknown = true)
public class PageVo {

    /**
     * 每页显示行数默认为10
     */
    private static final int DEFAULT_SIZE = 10;

    /**
     *  当前页码, 首页为1
     */
    private int page = 1;

    /**
     *  每页记录条数
     */
    private int size = DEFAULT_SIZE;

    /**
     *  排序字段名,asc,desc
     */
    private String sort;

    /**
     *  排序方向
     */
    private String dir;

    public static PageVo of(int page, int size) {
        PageVo pageReqVo = new PageVo();
        pageReqVo.setPage(page);
        pageReqVo.setSize(size);
        return pageReqVo;
    }

    public PageVo() {}

    @JsonIgnore
    public int getOffset() {
        return (getPage() - 1) * getSize();
    }

    public int getPage() {
        return page > 0 ? page : 1;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public int getSize() {
        return size > 0 ? size : DEFAULT_SIZE;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public String getSort() {
        return sort;
    }

    public void setSort(String sort) {
        this.sort = sort;
    }

    public String getDir() {
        return dir;
    }

    public void setDir(String dir) {
        this.dir = dir;
    }

}

分页结果类

import com.fasterxml.jackson.annotation.JsonPropertyOrder;

import java.util.List;

/**
 * <p>
 *      分页查询结果
 * </p>
 *
 * @ClassName PageResultVo
 * @Author yww
 * @Date 2022/10/24 21:15
 */
@JsonPropertyOrder({"start", "size", "total", "rows"})
public class PageResultVo<T> {

    /**
     *  本页记录在所有记录中的起始位置
     */
    private int start;

    /**
     *  每页记录条数
     */
    private int size;

    /**
     *  总记录条数
     */
    private int total;

    /**
     *  当前页数据
     */
    private List<T> rows;

    public static <E> PageResultVo<E> ofReqVo(PageVo reqVo, List<E> rows, int total) {
        PageResultVo<E> pageResultVo = new PageResultVo<>();
        pageResultVo.setSize(reqVo.getSize());
        pageResultVo.setStart(reqVo.getOffset());
        pageResultVo.setTotal(total);
        pageResultVo.setRows(rows);
        return pageResultVo;
    }

    public PageResultVo() {
    }

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getTotal() {
        return total;
    }

    public void setTotal(int total) {
        this.total = total;
    }

    public List<T> getRows() {
        return rows;
    }

    public void setRows(List<T> rows) {
        this.rows = rows;
    }

}

分页工具类

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.ISqlSegment;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
import com.baomidou.mybatisplus.core.conditions.segments.NormalSegmentList;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yww.management.common.exception.GlobalException;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 *      分页工具类
 * </p>
 *
 * @ClassName PageUtil
 * @Author yww
 * @Date 2022/10/24 21:21
 */
@SuppressWarnings("all")
public class PageUtil {

    /**
     * mybatis-plus自带分页插件
     *
     * @param pageVo
     * @param mapper
     * @param clazz
     * @param <R>
     * @param <Q>
     * @return
     */
    public static <R, Q extends PageVo> PageResultVo<R> paging(Q pageVo, BaseMapper<R> mapper, Class<R> clazz) {
        R entity;
        try {
            entity = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new GlobalException("分页类型转换错误");
        }
        BeanUtil.copyProperties(pageVo, entity);
        IPage<R> page = new Page<>(pageVo.getPage(), pageVo.getSize());
        page = mapper.selectPage(page, Wrappers.lambdaQuery(entity));
        return PageResultVo.ofReqVo(pageVo, page.getRecords(), Long.valueOf(page.getTotal()).intValue());
    }

    /**
     * mybatis-plus自带分页插件
     *
     * @param pageVo
     * @param mapper
     * @param <R>
     * @param <Q>
     * @return
     */
    public static <R, Q extends PageVo> PageResultVo<R> paging(Q pageVo, BaseMapper<R> mapper, LambdaQueryWrapper<R> lambdaQuery, Class<R> clazz) {
        R entity;
        try {
            entity = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new GlobalException("分页类型转换错误");
        }
        // 已设置在lambdaQuery的字段实体类中不应该重复设置
        String[] whereFields = getWhereFields(lambdaQuery);
        BeanUtil.copyProperties(pageVo, entity, whereFields);
        lambdaQuery.setEntity(entity);
        IPage<R> page = new Page<>(pageVo.getPage(), pageVo.getSize());
        page = mapper.selectPage(page, lambdaQuery);
        return PageResultVo.ofReqVo(pageVo, page.getRecords(), Long.valueOf(page.getTotal()).intValue());
    }

    /**
     * 获取设置的条件字段名
     *
     * @param lambdaQuery
     * @param <R>
     * @return
     */
    public static <R> String[] getWhereFields(LambdaQueryWrapper<R> lambdaQuery) {
        List<String> fields = new ArrayList<>();
        MergeSegments expression = lambdaQuery.getExpression();
        NormalSegmentList normal = expression.getNormal();
        int index = 0;
        for (ISqlSegment iSqlSegment : normal) {
            if (index % 4 == 0) {
                String field = StrUtil.toCamelCase(iSqlSegment.getSqlSegment());
                fields.add(field);
            }
            index++;
        }
        return fields.toArray(new String[]{});
    }

}