常用工具类

1、DateUtil

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * 日期工具类
 *
 * @author yangyongjie
 * @date 2019/9/24
 * @desc
 */
public class DateUtil {
    private DateUtil() {
    }

    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);

    public static final String YYYYMMDD_HHMMSS = "yyyy-MM-dd HH:mm:ss";

    public static final String YYYYMMDD = "yyyy-MM-dd";

    public static final String YYYYMMHHMMSSS = "yyyyMMddHHmmssS";


    public static String getMonth(Timestamp time) {
        return new SimpleDateFormat("yyyyMM").format(time);
    }

    /**
     * 将Date格式化为字符串，默认yyyy-MM-dd HH:mm:ss格式
     *
     * @param date
     * @return
     */
    public static String formatDate(Date date) {
        return formatDate(date, YYYYMMDD_HHMMSS);
    }

    /**
     * 将Date格式化为字符串根据传入的格式
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String formatDate(Date date, String pattern) {
        if (date == null) {
            return null;
        }
        if (StringUtils.isEmpty(pattern)) {
            return formatDate(date);
        }
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.format(date);
    }

    /**
     * 将指定格式的日期字符串解析为Date
     *
     * @param dateStr
     * @param pattern
     * @return
     */
    public static Date parseDate(String dateStr, String pattern) {
        if (StringUtils.isEmpty(dateStr) || StringUtils.isEmpty(pattern)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            LOGGER.error("解析日期字符串异常" + e.getMessage(), e);
        }
        return date;
    }

    /**
     * 讲默认格式的日期字符串解析为Date
     *
     * @param dateStr
     * @return
     */
    public static Date parseDate(String dateStr) {
        return parseDate(dateStr, YYYYMMDD_HHMMSS);
    }

    /**
     * 获取当前时间的时间戳
     *
     * @return
     */
    public static String getTimeInMillis() {
        long timeInMillis = Calendar.getInstance().getTimeInMillis();
        return timeInMillis + "";
    }

    /**
     * 获取当前时间的字符串
     *
     * @return
     */
    public static String getCurrentDate() {
        return formatDate(new Date(), YYYYMMDD_HHMMSS);
    }

    /**
     * 获取当前时间的秒数
     *
     * @return
     */
    public static int currentTimeSec() {
        return (int) (System.currentTimeMillis() / 1000);
    }

    /**
     * 获取当前时间往后的第几天的时间，为负表示前几天的时间
     *
     * @param i
     * @return
     */
    public static Date getBeforeOrNextDay(int i) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.DAY_OF_MONTH, i);
        return calendar.getTime();
    }

    /**
     * 获得当前时间的n秒前或后
     *
     * @param origin
     * @param seconds
     * @return
     */
    public static Date getIntervalSeconds(Date origin, long seconds) {
        return new Date(origin.getTime() + seconds * 1000L);
    }

}

2、LogUtil：用于发送错误日志邮件

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 日志工具类，用来发送错误邮件
 *
 * @author yangyongjie
 * @date 2019/11/1
 * @desc
 */
public class LogUtil {
    private LogUtil() {
    }

    private static final Logger LOGGER = LoggerFactory.getLogger(LogUtil.class);

    /**
     * 创建一个用于发送邮件的线程池，核心线程数为1，最大线程数为5，线程空闲时间为60s，拒绝策略为打印日志
     */
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            1,
            5,
            60,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(100),
            new CustomThreadFactory("sendErrorMail"),
            (r, executor) -> {
                // 只打印日志，什么都不做
                LOGGER.error("Task{},rejected from{}", r.toString(), executor.toString());
            });

    /**
     * 打印日志并发送错误邮件
     *
     * @param msg
     * @param t
     */
    public static void LogAndMail(String msg, Throwable t) {
        // 获取调用此工具类的该方法 的调用方信息
        // 查询当前线程的堆栈信息
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        // 按照规则，此方法的上一级调用类为
        StackTraceElement ste = stackTrace[2];
        String className = ste.getClassName();
        String methodName = ste.getMethodName();
        LOGGER.error("{}#{},{}," + t.getMessage(), className, methodName, msg, t);
        // 异步发送邮件
        String ms = "[" + ThreadContext.currentThreadContext().getThreadId() + "]" + msg;
        executor.execute(() -> ErrorMailUtil.sendErrorMail(ms, t, 3));
    }

    /**
     * 只发送错误邮件不打印日志
     *
     * @param msg
     */
    public static void sendErrorLogMail(String msg, Throwable t) {
        // 异步发送邮件
        String ms = "[" + ThreadContext.currentThreadContext().getThreadId() + "]" + msg + assembleStackTrace(t);
        executor.execute(() -> ErrorMailUtil.sendErrorMail(ms, t, 3));
    }

    /**
     * 组装异常堆栈
     *
     * @param t
     * @return
     */
    public static String assembleStackTrace(Throwable t) {
        StringWriter sw = new StringWriter();
        PrintWriter ps = new PrintWriter(sw);
        t.printStackTrace(ps);
        return sw.toString();
    }
}

3、HttpParamUtil：

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * Http 参数处理相关工具类
 *
 * @author yangyongjie
 * @date 2019/10/28
 * @desc
 */
public class HttpParamUtil {

    private HttpParamUtil() {
    }

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpParamUtil.class);

    /**
     * 获取request中的body信息 JSON格式
     *
     * @param request
     * @return
     */
    public static String getRequestBody(HttpServletRequest request) {
        StringBuilder bodyDataBuilder = new StringBuilder();
        BufferedReader br = null;
        try {
            br = request.getReader();
            String str;
            while ((str = br.readLine()) != null) {
                bodyDataBuilder.append(str);
            }
            br.close();
        } catch (IOException e) {
            LOGGER.error(e.getMessage(), e);
        } finally {
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    LOGGER.error(e.getMessage(), e);
                }
            }
        }

       /* InputStream is = null;
        try {
            is = request.getInputStream();
            byte[] b = new byte[4096];
            for (int n; (n = is.read(b)) != -1; ) {
                bodyDataBuilder.append(new String(b, 0, n));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }*/
        String bodyString = bodyDataBuilder.toString();
        LOGGER.info("bodyString={}", bodyString);
        return bodyString;
    }

    /**
     * 获取request中的body信息，并组装好按“参数=参数值”的格式
     *
     * @param request
     * @return
     */
    public static String getAssembleRequestBody(HttpServletRequest request) {
        String bodyString = getRequestBody(request);
        Map<String, Object> originMap = JacksonUtil.toObject(bodyString, Map.class);
        Map<String, Object> sortedParams = getSortedMap(originMap);
        String assembleBody = getSignContent(sortedParams);
        return assembleBody;
    }

    /**
     * 根据requestBody中的原始map获取解析后并组装的参数字符串，根据&符拼接
     *
     * @param originMap
     * @return
     */
    public static String getAssembleParam(Map<String, Object> originMap) {
        return getSignContent(getSortedMap(originMap));
    }


    /**
     * 将body转成按key首字母排好序
     *
     * @return
     */
    public static Map<String, Object> getSortedMap(Map<String, Object> originMap) {
        Map<String, Object> sortedParams = new TreeMap<String, Object>();
        if (originMap != null && originMap.size() > 0) {
            sortedParams.putAll(originMap);
        }
        return sortedParams;
    }

    /**
     * 将排序好的map的key和value拼接成字符串
     *
     * @param sortedParams
     * @return
     */
    public static String getSignContent(Map<String, Object> sortedParams) {
        StringBuffer content = new StringBuffer();
        List<String> keys = new ArrayList<String>(sortedParams.keySet());
        Collections.sort(keys);
        int index = 0;
        for (int i = 0; i < keys.size(); i++) {
            String key = keys.get(i);
            Object value = sortedParams.get(key);
            if (StringUtils.isNotEmpty(key) && value != null) {
                content.append((index == 0 ? "" : "&") + key + "=" + value);
                index++;
            }
        }
        return content.toString();
    }

    /**
     * Json转实体对象
     *
     * @param jsonStr
     * @param clazz   目标生成实体对象
     * @return
     */
    public static <T> T fromJsonToObject(String jsonStr, Class clazz) {
        T results = null;
        try {
            results = (T) JacksonUtil.toObject(jsonStr, clazz);
        } catch (Exception e) {
        }
        return results;
    }

    /**
     * 对请求参数进行校验，目前只进行非空校验
     *
     * @param tarObj 目标实体类
     * @return 校验成功返回true
     */
    public static <T> boolean paramCheck(T tarObj) {
        try {
            Class<T> tarClass = (Class<T>) tarObj.getClass();
            List<Field> fields = new ArrayList<>();
            fields.addAll(Arrays.asList(tarClass.getDeclaredFields()));
            Class supClass = tarClass.getSuperclass();
            while (supClass != null) {
                fields.addAll(Arrays.asList(supClass.getDeclaredFields()));
                supClass = supClass.getSuperclass();
            }
            for (Field field : fields) {
                field.setAccessible(true);
                ParamVerify verify = field.getAnnotation(ParamVerify.class);
                if (verify != null) {
                    //非空校验，后续若需增加校验类型，应抽离
                    if (verify.nullable() == CheckEnum.NOTNULL) {
                        Object val = field.get(tarObj);
                        if (val == null || "".equals(val.toString())) {
                            return false;
                        }
                    }
                }
            }
        } catch (Exception ex) {
            LOGGER.info("Param verify error");
            return false;
        }
        return true;
    }

}

/**
 * 字段校验注解，目前只进行非空校验，可扩展，用在字段上
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ParamVerify {
    /**
     * 是否允许为空
     */
    CheckEnum nullable() default CheckEnum.NULL;
}

public enum CheckEnum {
    NOTNULL,
    NULL

4、MD5Util：

public class MD5Util {
    private MD5Util() {
    }

    public static String getMD5(String message) {
        return message != null && message.length() != 0 ? getMD5(message.getBytes()) : "";
    }

    public static String getMD5(byte[] bytes) {
        if (bytes == null) {
            return "";
        } else {
            String digest = "";

            try {
                MessageDigest algorithm = MessageDigest.getInstance("MD5");
                algorithm.reset();
                algorithm.update(bytes);
                digest = toHexString(algorithm.digest());
            } catch (Exception var3) {
            }

            return digest;
        }
    }

    private static String toHexString(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        byte[] var5 = bytes;
        int var4 = bytes.length;

        for (int var3 = 0; var3 < var4; ++var3) {
            byte b = var5[var3];

            String str;
            for (str = Integer.toHexString(255 & b); str.length() < 2; str = "0" + str) {
            }

            hexString.append(str);
        }

        return hexString.toString();
    }
}

END.