常用工具类

计算当天开始时间和结束时间

DateTime date = DateUtil.date();
String startDateStr = DateUtil.formatDateTime(DateUtil.beginOfDay(date));
String endDateStr = DateUtil.formatDateTime(DateUtil.beginOfDay(DateUtil.offsetDay(date,1)));
params.put("startDate",startDateStr);
params.put("endDate",endDateStr);

1-数组工具类（ArrayUtils）

package com.tianji.common.utils;
import cn.hutool.core.util.ArrayUtil;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
 * 数组工具类
 * @ClassName ArrayUtils
 **/
public class ArrayUtils extends ArrayUtil {
    /**
     * 将源数组转换成指定类型的列表
     *
     * @param originList  原始列表
     * @param targetClazz 转换后列表元素的类型
     * @param          原始列表元素的类型
     * @param          目标列表元素的类型
     * @return 目标类型的集合
     */
    public static  List convert(R[] originList, Class targetClazz) {
       return convert(originList, targetClazz, null);
    }
    /**
     * 将源数组转换成指定类型的列表
     *
     * @param originList  原始列表
     * @param targetClazz 转换后列表元素的类型
     * @param convert     转换特殊字段接口
     * @param          原始列表元素的类型
     * @param          目标列表元素的类型
     * @return 目标类型的集合
     */
    public static  List convert(R[] originList, Class targetClazz, Convert convert) {
        if (isEmpty(originList)) {
            return null;
        }
        return Arrays.stream(originList)
                .map(origin -> BeanUtils.copyBean(origin, targetClazz, convert))
                .collect(Collectors.toList());
    }
}

2-AspectUtils

package com.tianji.common.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import java.lang.reflect.Method;
public class AspectUtils {
    /**
     * 获取被拦截方法对象
     * MethodSignature.getMethod() 获取的是顶层接口或者父类的方法对象
     * 所以应该使用反射获取当前对象的方法对象
     */
    public static Method getMethod(ProceedingJoinPoint pjp) {
        //获取参数的类型
        Signature sig = pjp.getSignature();
        if (sig instanceof MethodSignature) {
            MethodSignature methodSignature = (MethodSignature) sig;
            return methodSignature.getMethod();
        } else {
            throw new IllegalArgumentException("It's not method");
        }
    }
    /**
     * 在aop切面中SPEL表达式对formatter进行格式化，
     * 转换出指定的值
     *
     * @param formatter
     * @param method
     * @param args
     * @return
     */
    public static String parse(String formatter, Method method, Object[] args) {
        LocalVariableTableParameterNameDiscoverer nameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
        return SPELUtils.parse(formatter, nameDiscoverer.getParameterNames(method), args);
    }
}

3-断言工具类

package com.tianji.common.utils;
import com.tianji.common.constants.ErrorInfo;
import com.tianji.common.exceptions.BadRequestException;
import java.util.Map;
public class AssertUtils {
    public static void equals(Object obj1, Object obj2, String ... message){
        if (obj1 == null || obj2 == null) {
            handleException(message);
            return;
        }
        if (obj1 == obj2) {
            return;
        }
        if(!obj1.equals(obj2)){
            handleException(message);
        }
    }
    public static void isNotNull(Object obj, String ... message){
        if (obj == null) {
            handleException(message);
        }
    }
    public static void isNotBlank(String str, String ... message){
        if (StringUtils.isBlank(str)) {
            handleException(message);
        }
    }
    public static void isTrue(Boolean boo, String... message) {
        if (BooleanUtils.isFalse(boo)) {
            handleException(message);
        }
    }
    public static void isFalse(Boolean boo, String... message) {
        if (BooleanUtils.isTrue(boo)) {
            handleException(message);
        }
    }
    private static void handleException(String ... message){
        String msg = ErrorInfo.Msg.REQUEST_PARAM_ILLEGAL;
        if(message != null && message.length > 0){
            msg = message[0];
        }
        throw new BadRequestException(msg);
    }
    public static void isNotEmpty(Iterable coll, String ... message) {
        if(CollUtils.isEmpty(coll)){
            handleException(message);
        }
    }
    public static void isNotEmpty(Map map, String ... message) {
        if(CollUtils.isEmpty(map)){
            handleException(message);
        }
    }
}

4-BeanUtils

package com.tianji.common.utils;
import cn.hutool.core.bean.BeanUtil;
import java.util.List;
import java.util.stream.Collectors;
/**
 * 继承自 hutool 的BeanUtil，增加了bean转换时自定义转换器的功能
 */
public class BeanUtils extends BeanUtil {
    /**
     * 将原对象转换成目标对象，对于字段不匹配的字段可以使用转换器处理
     *
     * @param source  原对象
     * @param clazz   目标对象的class
     * @param convert 转换器
     * @param      原对象类型
     * @param      目标对象类型
     * @return 目标对象
     */
    public static  T copyBean(R source, Class clazz, Convert convert) {
        T target = copyBean(source, clazz);
        if (convert != null) {
            convert.convert(source, target);
        }
        return target;
    }
    /**
     * 将原对象转换成目标对象，对于字段不匹配的字段可以使用转换器处理
     *
     * @param source  原对象
     * @param clazz   目标对象的class
     * @param      原对象类型
     * @param      目标对象类型
     * @return 目标对象
     */
    public static  T copyBean(R source, Class clazz){
        if (source == null) {
            return null;
        }
        return toBean(source, clazz);
    }
    public static  List copyList(List list, Class clazz) {
        if (list == null || list.size() == 0) {
            return CollUtils.emptyList();
        }
        return copyToList(list, clazz);
    }
    public static  List copyList(List list, Class clazz, Convert convert) {
        if (list == null || list.size() == 0) {
            return CollUtils.emptyList();
        }
        return list.stream().map(r -> copyBean(r, clazz, convert)).collect(Collectors.toList());
    }
}