java语言时间表达式引擎

自己用的一个需要解析时间格式表达式的小工具类：

 

/**
 * <pre>
 * Copyright CDC [2000-2015]
 * </pre>
 */
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;

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

/**
 * <pre>
 * DateExpressionEngine.java
 * @author kanpiaoxue<br>
 * @version 1.0
 * Create Time 2015年6月4日 下午7:16:02<br>
 * Description : 时间表达式引擎
 * </pre>
 */
public class DateExpressionEngine {

    private static final String REGEX = "(\\$\\{(.*?)\\})";

    private static final Pattern PATTERN = Pattern.compile(REGEX);

    private static final Pattern DATE_PATTERN = Pattern.compile("^\\d{8,}$");

    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 String OFFSET_REGEX = "^(-?\\d+?)?([y,Y,M,w,W,d,D,H,h,m])$";

    private static final Pattern OFFSET_PATTERN = Pattern.compile(OFFSET_REGEX);
    private static final String OFFSET_SPECIAL_REGEX = "^([F,f,E,e])([M,w,W,q,Q])$";

    private static final Pattern OFFSET_SPECIAL_PATTERN = Pattern
            .compile(OFFSET_SPECIAL_REGEX);

    private static KeyValue<String, String> correctDataVersionNo(String format,
            String dataVersionNo) {

        format = format.trim();
        // "yyyy-MM-dd HH:mm:ss.SSS"
        // "yyyy/MM/dd HH:mm:ss.SSS"
        format = StringUtils.replaceEachRepeatedly(format, new String[] { "-",
                "/", " ", ":", "." }, new String[] { "", "", "", "", "" });

        int formatLength = format.length();
        int dataVersionNoLength = dataVersionNo.length();
        int num = dataVersionNoLength - formatLength;
        if (num > 0) {
            dataVersionNo = dataVersionNo.substring(0, formatLength);
        } else if (num < 0) {
            dataVersionNo = Strings.padEnd(dataVersionNo,
                    (dataVersionNoLength + Math.abs(num)), '0');
        }
        return new KeyValue<String, String>(format, dataVersionNo);
    }

    /**
     * <pre>
     * @param needProcessString 需要处理的字符串
     *  里面可以含有任意多个时间表达式
     *  格式：${yyyy[-/]MM[-/]dd[ ][HH[:]mm][,offset]}
     *  
     *  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:
     *      ${yyyyMMdd} ${yyyy-MM-dd} ${yyyy/MM/dd}
     *      ${yyyyMMddHH} ${yyyy-MM-dd HH} ${yyyy/MM/dd HH}
     *      ${yyyyMMddHHmm} ${yyyy-MM-dd HH:mm} ${yyyy/MM/dd HH:mm}
     *      ${yyyyMMdd,-1y} ${yyyy-MM-dd,-1y} ${yyyy/MM/dd,-1y}
     *      ${yyyyMMdd,-1M} ${yyyy-MM-dd,-1M} ${yyyy/MM/dd,-1M}
     *      ${yyyyMMdd,1d} ${yyyy-MM-dd,1d} ${yyyy/MM/dd,1d}
     *      ${yyyyMMddHH,1H} ${yyyy-MM-dd HH,1H} ${yyyy/MM/dd HH,1H}
     *      ${yyyyMMdd,1w} ${yyyy-MM-dd,1w} ${yyyy/MM/dd,1w}
     *      ${yyyyMMddHHmm,10m} ${yyyy-MM-dd HH:mm,10m} ${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
     *  
     * @param dateValue 时间的字符串，格式要求 yyyyMMdd,yyyyMMddHH,yyyyMMddHHmm
     * @return 经过计算之后的字符串
     * </pre>
     */
    public static String formatDateExpression(String needProcessString,
            String dateValue) {
        Preconditions.checkArgument(StringUtils.isNotBlank(needProcessString));
        Preconditions.checkArgument(StringUtils.isNotBlank(dateValue));
        Preconditions
                .checkArgument(
                        DATE_PATTERN.matcher(dateValue).matches(),
                        "dateValue is unexpect format:%s. "
                                + "Required min length is 8, like : 20150101. %s's length is : %s",
                        dateValue, dateValue, dateValue.length());

        Matcher m = PATTERN.matcher(needProcessString);
        /**
         * 如果找到时间表达式则进行替换，如果找不到，则不进行处理
         */
        while (m.find()) {
            int groupFrist = 1;
            String expression = m.group(2);
            /**
             * <pre>
             * ${expression} is group(1) , as:  ${yyyyMMdd,-1y} , ${yyyyMMdd,FQ}
             * expression is group(2) , as: yyyyMMdd,-1y , yyyyMMdd,FQ
             * </pre>
             */
            int start = m.start(groupFrist);
            int end = m.end(groupFrist);
            String expressionWrapper = needProcessString.substring(start, end);
            String replaceMent = getCorrectDateString(expression, dateValue);
            needProcessString = StringUtils.replace(needProcessString,
                    expressionWrapper, replaceMent);
            // find next
            m = PATTERN.matcher(needProcessString);
        }
        return needProcessString;
    }

    private static String getCorrectDateString(String express,
            String dataVersionNo) {
        List<String> lst = Splitter.on(',').trimResults().omitEmptyStrings()
                .splitToList(express);
        int size = lst.size();
        Preconditions.checkArgument(size <= 2,
                "unexpected expression format:%s", express);
        String format = lst.get(0);
        KeyValue<String, String> obj = correctDataVersionNo(format,
                dataVersionNo);
        String tempFormat = obj.getKey();
        dataVersionNo = obj.getValue();
        DateTimeFormatter formatter = DateTimeFormat.forPattern(tempFormat);
        DateTime dateTime = DateTime.parse(dataVersionNo, formatter);
        DateTime rs = dateTime;
        if (lst.size() == 2) {
            String offsetExpression = lst.get(1);
            // 处理季度、月、周的第一天和最后一天
            Matcher sm = OFFSET_SPECIAL_PATTERN.matcher(offsetExpression);

            if (sm.matches()) {
                String str1 = sm.group(1);
                Preconditions.checkArgument(StringUtils.isNotBlank(str1),
                        "unexpected expression format:%s", express);
                String unit = sm.group(2);
                if (QUARTR_STRING.equalsIgnoreCase(unit)) {
                    DateTime startQuarter = dateTime
                            .plusMonths(
                                    0 - (dateTime.monthOfYear().get() - 1) % 3)
                            .dayOfMonth().withMinimumValue();
                    // 季度初
                    if (FIRST_STRING.equalsIgnoreCase(str1)) {
                        rs = startQuarter;
                    } else if (END_STRING.equalsIgnoreCase(str1)) {
                        rs = startQuarter.plusMonths(3).plusDays(-1);
                        // 季度末
                    } else {
                        throw new IllegalArgumentException(String.format(
                                "unexpected expression format:%s", express));
                    }
                } else if (MONTH_STRING.equals(unit)) {
                    if (FIRST_STRING.equalsIgnoreCase(str1)) {
                        rs = dateTime.dayOfMonth().withMinimumValue();
                    } else if (END_STRING.equalsIgnoreCase(str1)) {
                        rs = dateTime.dayOfMonth().withMaximumValue();
                    } else {
                        throw new IllegalArgumentException(String.format(
                                "unexpected expression format:%s", express));
                    }
                } else if (WEEK_STRING.equalsIgnoreCase(unit)) {
                    if (FIRST_STRING.equalsIgnoreCase(str1)) {
                        rs = dateTime.dayOfWeek().withMinimumValue();
                    } else if (END_STRING.equalsIgnoreCase(str1)) {
                        rs = dateTime.dayOfWeek().withMaximumValue();
                    } else {
                        throw new IllegalArgumentException(String.format(
                                "unexpected expression format:%s", express));
                    }
                }
                return rs.toString(format);
            }
            // 处理一般的时间表达式
            Matcher m = OFFSET_PATTERN.matcher(offsetExpression);
            Preconditions.checkArgument(m.matches(),
                    "unexpected expression format:%s", express);
            String numString = m.group(1);
            if (StringUtils.isBlank(numString)) {
                numString = "0";
            }
            int num = Integer.valueOf(numString).intValue();
            String unit = m.group(2);
            if (YEAR_STRING.equalsIgnoreCase(unit)) {
                // IgnoreCase
                rs = dateTime.plusYears(num);
            } else if (MONTH_STRING.equals(unit)) {
                rs = dateTime.plusMonths(num);
            } else if (WEEK_STRING.equalsIgnoreCase(unit)) {
                // IgnoreCase
                rs = dateTime.plusWeeks(num);
            } else if (DAY_STRING.equalsIgnoreCase(unit)) {
                // IgnoreCase
                rs = dateTime.plusDays(num);
            } else if (HOUR_STRING.equalsIgnoreCase(unit)) {
                // IgnoreCase
                rs = dateTime.plusHours(num);
            } else if (MINUTE_STRING.equals(unit)) {
                rs = dateTime.plusMinutes(num);
            } else {
                throw new IllegalArgumentException(String.format(
                        "unexpected expression format:%s", express));
            }
        }
        return rs.toString(format);
    }
}

 

 

 

/**
 * <pre>
 * Copyright CDC [2000-2015]
 * </pre>
 */
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import org.junit.Test;

import com.google.common.collect.Lists;

import java.util.List;

/**
 * <pre>
 * DateExpressionEngineTest.java
 * @author kanpiaoxue<br>
 * @version 1.0
 * Create Time 2015年6月4日 下午7:29:22<br>
 * Description : DateExpressionEngine测试类
 * </pre>
 */
public class DateExpressionEngineTest {

    /**
     * Test method for
     * {@link com.baidu.rigel.dmap.sf.utils.DateExpressionEngine#formatDateExpression(java.lang.String, java.lang.String)}
     * .
     */
    @Test
    public void testFormatDateExpression() {
        String needProcessString = null;
        String dateValue = "20150604";
        try {
            DateExpressionEngine.formatDateExpression(needProcessString,
                    dateValue);
            fail("error");
        } catch (Exception e) {
            assertTrue(true);
        }
        needProcessString = "${yyyyMMdd}";
        dateValue = null;
        try {
            DateExpressionEngine.formatDateExpression(needProcessString,
                    dateValue);
            fail("error");
        } catch (Exception e) {
            assertTrue(true);
        }
        needProcessString = "${yyyyMMdd}";
        dateValue = "2015060";
        try {
            DateExpressionEngine.formatDateExpression(needProcessString,
                    dateValue);
            fail("error");
        } catch (Exception e) {
            assertTrue(true);
        }
        needProcessString = "${yyyyMMdd,-1d,3w}";
        dateValue = "2015060";
        try {
            DateExpressionEngine.formatDateExpression(needProcessString,
                    dateValue);
            fail("error");
        } catch (Exception e) {
            assertTrue(true);
        }

        needProcessString = "${yyyyMMdd,-1d,3X}";
        dateValue = "2015060";
        try {
            DateExpressionEngine.formatDateExpression(needProcessString,
                    dateValue);
            fail("error");
        } catch (Exception e) {
            assertTrue(true);
        }
        needProcessString = "${yyyyMMdd}";
        dateValue = "20150604";
        String rs = DateExpressionEngine.formatDateExpression(
                needProcessString, dateValue);
        System.out.println(rs);
        assertEquals("20150604", rs);

        needProcessString = "${yyyy-MM-dd}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04", rs);

        needProcessString = "${yyyyMMddHH}";
        dateValue = "2015060401";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015060401", rs);

        needProcessString = "${yyyy-MM-dd HH}";
        dateValue = "2015060401";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04 01", rs);

        needProcessString = "${yyyyMMddHHmm}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("201506040101", rs);

        needProcessString = "${yyyy/MM/dd HH:mm}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015/06/04 01:01", rs);

        needProcessString = "${yyyyMMdd,-1y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20140604", rs);

        needProcessString = "${yyyy-MM-dd,-1y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2014-06-04", rs);

        needProcessString = "${yyyyMMdd,0y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150604", rs);

        needProcessString = "${yyyy-MM-dd,0y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04", rs);

        needProcessString = "${yyyyMMdd,10y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20250604", rs);

        needProcessString = "${yyyy/MM/dd,10y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2025/06/04", rs);

        needProcessString = "${yyyyMMdd,10Y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20250604", rs);

        needProcessString = "${yyyy-MM-dd,10Y}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2025-06-04", rs);

        needProcessString = "${yyyyMMdd,-2M}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150404", rs);

        needProcessString = "${yyyy/MM/dd,-2M}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015/04/04", rs);

        needProcessString = "${yyyyMMdd,2M}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150804", rs);

        needProcessString = "${yyyy-MM-dd,2M}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-08-04", rs);

        needProcessString = "${yyyyMMdd,1w}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150611", rs);

        needProcessString = "${yyyy-MM-dd,1w}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-11", rs);

        needProcessString = "${yyyyMMdd,-1w}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150528", rs);

        needProcessString = "${yyyy-MM-dd,-1w}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-05-28", rs);

        needProcessString = "${yyyyMMdd,-3d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150601", rs);

        needProcessString = "${yyyy-MM-dd,-3d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-01", rs);

        needProcessString = "${yyyyMMdd,0d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150604", rs);

        needProcessString = "${yyyy-MM-dd,0d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04", rs);

        needProcessString = "${yyyyMMdd,11d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150615", rs);

        needProcessString = "${yyyy-MM-dd,11d}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-15", rs);

        needProcessString = "${yyyyMMdd,24h}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150605", rs);

        needProcessString = "${yyyy-MM-dd,24h}";
        dateValue = "20150604";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-05", rs);

        needProcessString = "${yyyyMMddHHmm,24h}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("201506050101", rs);

        needProcessString = "${yyyy-MM-dd HH:mm,24h}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-05 01:01", rs);

        needProcessString = "${yyyyMMddHHmm,24m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("201506040125", rs);

        needProcessString = "${yyyy-MM-dd HH:mm,24m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04 01:25", rs);

        needProcessString = "${yyyyMMddHHmm,-4m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("201506040057", rs);

        needProcessString = "${yyyy-MM-dd     HH:mm,-4m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-04     00:57", rs);

        needProcessString = "${yyyyMMddHHmm,m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("201506040101", rs);

        needProcessString = "${yyyy-MM-ddHHmm,m}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-040101", rs);

        needProcessString = "hello";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("hello", rs);

        needProcessString = "hello";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("hello", rs);

        needProcessString = "${yyyyMMdd}hello${yyyyMMdd,11d}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150604hello20150615", rs);

        needProcessString = "${yyyy-MM/dd}hello${yyyy/MM-dd,11d}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06/04hello2015/06-15", rs);

        needProcessString = "${yyyyMMdd,fq}hello${yyyyMMdd,EQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150401hello20150630", rs);

        needProcessString = "${yyyy-MM-dd,fq}hello${yyyy/MM/dd,EQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-04-01hello2015/06/30", rs);

        needProcessString = "${yyyyMMdd,Fq}hello${yyyyMMdd,EQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150401hello20150630", rs);

        needProcessString = "${yyyy-MM-dd,Fq}hello${yyyyMMdd,EQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-04-01hello20150630", rs);

        needProcessString = "${yyyyMMdd,Fq}hello${yyyyMMdd,eQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150401hello20150630", rs);

        needProcessString = "${yyyy MM dd,Fq}hello${yyyyMMdd,eQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015 04 01hello20150630", rs);

        needProcessString = "${yyyy-MM-dd,Fq}hello${yyyy/MM/dd,eQ}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-04-01hello2015/06/30", rs);

        needProcessString = "${yyyyMMdd,FM}hello${yyyyMMdd,eM}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150601hello20150630", rs);

        needProcessString = "${yyyy-MM-dd,FM}hello${yyyyMMdd,eM}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-01hello20150630", rs);

        needProcessString = "${yyyyMMdd,Fw}hello${yyyyMMdd,eW}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("20150601hello20150607", rs);

        needProcessString = "${yyyy-MM-dd,Fw}hello${yyyyMMdd,eW}";
        dateValue = "201506040101";
        rs = DateExpressionEngine.formatDateExpression(needProcessString,
                dateValue);
        System.out.println(rs);
        assertEquals("2015-06-01hello20150607", rs);

        List<String> cmds = Lists.newArrayList();
        cmds.add("cd /home/work/etl/cdc-etl-sme/${yyyyMMdd,-1y}/scripts && sh +x run.sh "
                + "ods/${yyyyMMdd}/baike/baike_launch_cost_log ${yyyyMMdd,-1d} ${yyyyMMdd,-1y}"
                + " ${yyyyMMdd,-2d} ${yyyyMMddHHmm,-3H} ${yyyyMMdd,-1w} ${yyyyMMdd,10y} ${yyyyMMdd,8d}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/${yyyy-MM-dd,-1y}/scripts && sh +x run.sh "
                + "ods/${yyyy-MM-dd}/baike/baike_launch_cost_log ${yyyy-MM-dd,-1d} ${yyyy-MM-dd,-1y}"
                + " ${yyyy-MM-dd,-2d} ${yyyy-MM-dd HH:mm,-3H} ${yyyy/MM/dd,-1w} ${yyyy/MM/dd,10y} ${yyyy/MM/dd,8d}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMddHH}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy-MM-dd HH}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMddHHmm}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy-MM-dd HH:mm}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMdd,-1y}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy-MM-dd,-1y}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMdd,-1M}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy-MM-dd,-1M}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMdd,1d}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy/MM/dd,1d}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts ${yyyyMMddHHmm,-1d} && sh"
                + " +x run.sh ods/baike/baike_launch_cost_log ${yyyyMMddHH,1H}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts ${yyyy-MM-dd HH:mm,-1d} && sh"
                + " +x run.sh ods/baike/baike_launch_cost_log ${yyyy/MM/dd HH,1H}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyyMMddHHmm,10m}");
        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log ${yyyy-MM-dd HH:mm,10m}");

        cmds.add("cd /home/work/etl/cdc-etl-sme/scripts && sh +x run.sh"
                + " ods/baike/baike_launch_cost_log");

        // String dataVersionNo = "201501010101";
        String dataVersionNo = "20150101";

        int i = 0;
        for (String cmd : cmds) {
            cmd = DateExpressionEngine.formatDateExpression(cmd, dataVersionNo);
            if (i % 2 == 0) {
                System.out.println("===================");
            }
            System.out.println(cmd);
            i++;
        }
    }

}

 

/**
 * <pre>
 * KeyValue.java
 * @author kanpiaoxue<br>
 * @version 1.0
 * Create Time 2014年9月18日 下午1:50:33<br>
 * Description : key : value 的键值类
 * </pre>
 */
public class KeyValue<K, V> extends Key<K> {
    /**
     * <pre>
     * </pre>
     */

    private static final long serialVersionUID = -5805488471492686888L;
    private V value;

    /**
     * <pre>
     * </pre>
     */
    public KeyValue() {
        super();
    }

    /**
     * <pre>
     * @param key
     * </pre>
     */
    public KeyValue(K key) {
        super(key);
    }

    /**
     * <pre>
     * @param key
     * @param value
     * </pre>
     */
    public KeyValue(K key, V value) {
        super();
        this.key = key;
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        @SuppressWarnings("rawtypes")
        KeyValue other = (KeyValue) obj;
        if (key == null) {
            if (other.key != null) {
                return false;
            }
        } else if (!key.equals(other.key)) {
            return false;
        }
        if (value == null) {
            if (other.value != null) {
                return false;
            }
        } else if (!value.equals(other.value)) {
            return false;
        }
        return true;
    }

    @Override
    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((key == null) ? 0 : key.hashCode());
        result = prime * result + ((value == null) ? 0 : value.hashCode());
        return result;
    }

    @Override
    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "KeyValue [key=" + key + ", value=" + value + "]";
    }

}

 

import java.io.Serializable;

/**
 * <pre>
 * Key.java
 * @author kanpiaoxue<br>
 * @version 1.0
 * Create Time 2014年9月18日 下午2:24:53<br>
 * Description : 单值类
 * </pre>
 */
public class Key<K> implements Serializable {
    /**
     * <pre>
     * </pre>
     */

    private static final long serialVersionUID = 7532585206735018941L;
    protected K key;

    /**
     * <pre>
     * </pre>
     */
    public Key() {
        super();
    }

    /**
     * <pre>
     * @param key
     * </pre>
     */
    public Key(K key) {
        super();
        this.key = key;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        @SuppressWarnings("rawtypes")
        Key other = (Key) obj;
        if (key == null) {
            if (other.key != null) {
                return false;
            }
        } else if (!key.equals(other.key)) {
            return false;
        }
        return true;
    }

    public K getKey() {
        return key;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((key == null) ? 0 : key.hashCode());
        return result;
    }

    public void setKey(K key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return "Key [key=" + key + "]";
    }

}