java语言时间表达式引擎(2)

 

在原有《java语言时间表达式引擎》https://www.iteye.com/blog/kanpiaoxue-2217121 的基础上进行了精简。

时间表达式也进行了微调，改为： {dt:格式化字符串,offset}

 

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;

import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Maps;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 时间表达式引擎
 *
 * @ClassName: DateExpressionEngine
 * @author kanpiaoxue
 * @version 1.0
 * @CreateTime: 2020/06/29 20:28:06
 * @Description:
 */
public class DateExpressionEngine {

    private static final Pattern PATTERN = Pattern.compile("(\\{dt:(.*?)\\})");
    private static final Pattern OFFSET_PATTERN = Pattern.compile("^(-?\\d+?)?([y,Y,M,w,W,d,D,H,h,m])$");
    private static final Pattern OFFSET_SPECIAL_PATTERN = Pattern.compile("^([F,f,E,e])([M,w,W,q,Q])$");

    private static final String FIRST_STRING = "F";
    private static final String END_STRING = "E";
    private static final String YEAR_STRING = "y";
    private static final String QUARTR_STRING = "Q";
    private static final String MONTH_STRING = "M";
    private static final String WEEK_STRING = "w";
    private static final String DAY_STRING = "d";
    private static final String HOUR_STRING = "H";
    private static final String MINUTE_STRING = "m";
    private static final int PAIR_LENGTH = 2;
    private static final int ZERO = 0;

    /**
     *
     * @param text
     *            需要处理的字符串
     *
     *            <pre>
     *  里面可以含有任意多个时间表达式
     *  格式：dateFormat[,offset]}
     *  dateFormat: 符合java的java.text.DateFormat规范的表达式
     *  DateUnit 时间格式单位:[注意大小写]
     *      y   :   year
     *      M   :   Month
     *      d   :   day
     *      w   :   week
     *      H   :   Hour
     *      m   :   minute
     *
     *  [重点]这里的格式有两种，一种是一般日期表达式，一种是特殊表达式
     *
     *  一、一般日期表达式：
     *  offset的表达式：(-)?number+DateUnit
     *  offset的正则表达式： ^((?:-)?\\d+?)([y,M,w,d,H,m])$
     *
     *   example:
     *      {dt:MM} {dt:MMdd} {dt:MM/dd} {dt:HH} {dt:HHmm}
     *      {dt:yyyyMMdd} {dt:yyyy-MM-dd} {dt:yyyy/MM/dd}
     *      {dt:yyyyMMddHH} {dt:yyyy-MM-dd HH} {dt:yyyy/MM/dd HH}
     *      {dt:yyyyMMddHHmm} {dt:yyyy-MM-dd HH:mm} {dt:yyyy/MM/dd HH:mm}
     *      {dt:yyyyMMdd,-1y} {dt:yyyy-MM-dd,-1y} {dt:yyyy/MM/dd,-1y}
     *      {dt:yyyyMMdd,-1M} {dt:yyyy-MM-dd,-1M} {dt:yyyy/MM/dd,-1M}
     *      {dt:yyyyMMdd,1d} {dt:yyyy-MM-dd,1d} {dt:yyyy/MM/dd,1d}
     *      {dt:yyyyMMddHH,1H} {dt:yyyy-MM-dd HH,1H} {dt:yyyy/MM/dd HH,1H}
     *      {dt:yyyyMMdd,1w} {dt:yyyy-MM-dd,1w} {dt:yyyy/MM/dd,1w}
     *      {dt:yyyyMMddHHmm,10m} {dt:yyyy-MM-dd HH:mm,10m} {dt:yyyy/MM/dd HH:mm,10m}
     *
     * 二、特殊表达式
     *  用来计算：季度初/末，月初/末，周初/末（也就是周一和周日）
     *  offset的表达式：position+DateUnit
     *  offset的正则表达式：^([F,f,E,e])([M,w,W,q,Q])$
     *  ------------------
     *  F,f means: first
     *  E,e means: end
     *  ------------------
     *  M : Month
     *  w,W : Week
     *  q,Q : Quarter
     *
     *            </pre>
     *
     * @param dateTime
     *            时间
     * @return 经过计算之后的字符串
     */
    public static String formatDateExpression(String text, DateTime dateTime) {
        Preconditions.checkArgument(StringUtils.isNotBlank(text), "text is null or empty!");
        Preconditions.checkNotNull(dateTime, "dateTime is null");
        Matcher m = PATTERN.matcher(text);
        Map<String, String> map = Maps.newHashMap();

        /**
         * 如果找到时间表达式则进行替换，如果找不到，则不进行处理
         */
        while (m.find()) {
            /**
             * <pre>
             *
             * {dt:expression} is group(1) , as:  {dt:yyyyMMdd,-1y} , {dt:yyyyMMdd,FQ}
             * expression is group(2) , as: yyyyMMdd,-1y , yyyyMMdd,FQ
             * </pre>
             */
            String expression = m.group(2);
            // expressionWrapper : {dt:yyyyMMdd,-1y} , {dt:yyyyMMdd,FQ}
            String expressionWrapper = text.substring(m.start(1), m.end(1));
            // 格式化时间
            String replaceString = formatDateTime(expression, dateTime);
            map.put(expressionWrapper, replaceString);
        }
        // 替换表达式为正确的时间字符串
        for (Entry<String, String> kv : map.entrySet()) {
            text = StringUtils.replace(text, kv.getKey(), kv.getValue());
        }
        return text;
    }

    private static String formatDateTime(String express, DateTime dateTime) {
        // 将表达式切分开
        List<String> lst = Splitter.on(',').trimResults().omitEmptyStrings().splitToList(express);
        int size = lst.size();
        Preconditions.checkArgument(size <= PAIR_LENGTH, unexpected(express));
        // 如果存在复杂的计算表达式
        if (lst.size() == PAIR_LENGTH) {
            String offsetExpression = lst.get(1);
            // 处理季度、月、周的第一天和最后一天
            Matcher m = OFFSET_SPECIAL_PATTERN.matcher(offsetExpression);
            if (m.matches()) {
                dateTime = processFirstOrLast(express, dateTime, m);
            } else {
                // 处理一般的时间表达式
                dateTime = processNormal(express, dateTime, offsetExpression);
            }
        }
        // 得到时间表达式的格式化部分
        String format = lst.get(0);
        return dateTime.toString(format);
    }

    private static DateTime processFirstOrLast(String express, DateTime dateTime, Matcher sm) {
        String str = sm.group(1);
        Preconditions.checkArgument(StringUtils.isNotBlank(str), unexpected(express));
        String unit = sm.group(2);
        if (QUARTR_STRING.equalsIgnoreCase(unit)) {
            dateTime = processQuarter(express, dateTime, str);
        } else if (MONTH_STRING.equals(unit)) {
            dateTime = processMonth(express, dateTime, str);
        } else if (WEEK_STRING.equalsIgnoreCase(unit)) {
            dateTime = processWeek(express, dateTime, str);
        }
        return dateTime;
    }

    private static DateTime processMonth(String express, DateTime dateTime, String str1) {
        if (FIRST_STRING.equalsIgnoreCase(str1)) {
            dateTime = dateTime.dayOfMonth().withMinimumValue();
        } else if (END_STRING.equalsIgnoreCase(str1)) {
            dateTime = dateTime.dayOfMonth().withMaximumValue();
        } else {
            throw new IllegalArgumentException(unexpected(express));
        }
        return dateTime;
    }

    private static DateTime processNormal(String express, DateTime dateTime, String offsetExpression) {
        Matcher m = OFFSET_PATTERN.matcher(offsetExpression);
        Preconditions.checkArgument(m.matches(), unexpected(express));
        String numString = m.group(1);
        int num = StringUtils.isBlank(numString) ? ZERO : Integer.valueOf(numString).intValue();
        if (ZERO == num) {
            // 如果是 offset == 0， 不需要进行下面的单位转换，直接返回当前时间
            return dateTime;
        }

        String unit = m.group(2);
        if (YEAR_STRING.equalsIgnoreCase(unit)) {
            // IgnoreCase
            dateTime = dateTime.plusYears(num);
        } else if (MONTH_STRING.equals(unit)) {
            dateTime = dateTime.plusMonths(num);
        } else if (WEEK_STRING.equalsIgnoreCase(unit)) {
            // IgnoreCase
            dateTime = dateTime.plusWeeks(num);
        } else if (DAY_STRING.equalsIgnoreCase(unit)) {
            // IgnoreCase
            dateTime = dateTime.plusDays(num);
        } else if (HOUR_STRING.equalsIgnoreCase(unit)) {
            // IgnoreCase
            dateTime = dateTime.plusHours(num);
        } else if (MINUTE_STRING.equals(unit)) {
            dateTime = dateTime.plusMinutes(num);
        } else {
            throw new IllegalArgumentException(unexpected(express));
        }
        return dateTime;
    }

    private static DateTime processQuarter(String express, DateTime dateTime, String str) {
        DateTime startQuarter = dateTime.plusMonths(0 - (dateTime.monthOfYear().get() - 1) % 3).dayOfMonth()
                .withMinimumValue();
        if (FIRST_STRING.equalsIgnoreCase(str)) {
            // 季度初
            dateTime = startQuarter;
        } else if (END_STRING.equalsIgnoreCase(str)) {
            // 季度末
            dateTime = startQuarter.plusMonths(3).plusDays(-1);
        } else {
            throw new IllegalArgumentException(unexpected(express));
        }
        return dateTime;
    }

    private static DateTime processWeek(String express, DateTime dateTime, String str1) {
        if (FIRST_STRING.equalsIgnoreCase(str1)) {
            dateTime = dateTime.dayOfWeek().withMinimumValue();
        } else if (END_STRING.equalsIgnoreCase(str1)) {
            dateTime = dateTime.dayOfWeek().withMaximumValue();
        } else {
            throw new IllegalArgumentException(unexpected(express));
        }
        return dateTime;
    }

    private static String unexpected(String express) {
        return String.format("unexpected expression format:%s", express);
    }
}