public class CacheHelper {
    public final static int default_interval_second = 20;
    public static boolean   ISDEBUG                 = true;
    private static HashMap  map                     = new HashMap();
    private static Object   obj                     = new Object();

    public static ICache getCache(String uniquekey) {
        synchronized (obj) {
            ICache ic = (ICache) map.get(uniquekey);
            if (ic == null) {
                ic = new CacheEntity(uniquekey);
                map.put(uniquekey, ic);
            }
            return ic;
        }
    }

    public interface ICache {
        Object get();

        Object get(long timestamp);

        void set(Object obj);

        void set(long timestamp, Object obj);

        void clear(String regx);

        void clearAll();
    }

    private static class CacheEntity implements ICache {
        private Hashtable hm        = new Hashtable();
        private Object    uniquekey = this;
        private long      timestamp = Long.MIN_VALUE;

        public CacheEntity(Object uniquekey) {
            this.uniquekey = uniquekey;
        }

        public Object get(long timestamp) {
            if (timestamp <= this.timestamp) {
                // 当前时间在设定的过期时间之前，表示还没有过期。
                // 如果还没过期，那么就返回。
                Object obj = hm.get(uniquekey);
                if (ISDEBUG && obj != null) {
                    // 输出日志。
                    System.out.println("[" + timestamp + "][Reading cache][" + uniquekey + "]...");
                }
                return obj;
            }
            else {
                // 清理垃圾。
                hm.remove(uniquekey);
                return null;
            }
        }

        public void set(long timestamp, Object obj) {
            this.timestamp = timestamp;
            hm.put(uniquekey, obj);
        }

        public Object get() {
            Calendar cal = Calendar.getInstance();
            return get(cal.getTimeInMillis());
        }

        public void set(Object obj) {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.SECOND, default_interval_second);
            set(cal.getTimeInMillis(), obj);
        }

        public void clear(String regx) {
            java.util.Enumeration keys = hm.keys();
            while (keys.hasMoreElements()) {
                String key = (String) keys.nextElement();
                if (key.matches(regx)) {
                    hm.remove(key);
                }
            }
        }

        public void clearAll() {
            hm.clear();
        }
    }
}

import java.util.Arrays;

import cn.com.worksoft.util.log.LogFactory;
import cn.com.worksoft.util.log.Logger;

/**
*
* @author XING
*
* Create time 2004-12-2 16:52:48
*
* 本类的运算逻辑是 分为以下几个步骤:
* 1、格式化所输入的算式（去掉所有空格，＋－符号前面如果没有数字就补0，×/符号前面如果没有数字就补1，^~符号后面如果没有数字就补2，其它如果出现前后缺少的情况就报错）
* 2、获得的算式串，如A； 3、获取所有运算符号，寻找第一个需要运算的符号，基本规则是，找到最里层的（），然后在其内部找，^~ > /* > +-
* ，同类型的就从做至右运算； 4、获取该运算符号的两端变量，进行运算得出结果，将结果回填回去； 5、取得了新的运算串，存入A；
* 6、重复2直到A中没有运算符号为止； 7、得到结果。
*
* 更改所生成类型注释的模板为 窗口 > 首选项 > Java > 代码生成 > 代码和注释
*/
public final class TExpression {
public final static String ADD = "\\\\+";

public final static String DECREASE = "\\\\-";

public final static String[] DefaultVars = new String[]
{
"+",
"-",
"*",
"/",
"^",
"~", };

public final static String DIVIDE = "/";

public final static String FU = "GXFU";

public final static String LBRACKET = "\\\\(";

public final static String MULTIPLY = "\\\\*";

public final static String PERCENT = "%";

public final static String POWER = "\\\\^";

public final static String RBRACKET = "\\\\)";

public final static String SQRT = "~";

private final static Logger gLogger = LogFactory.defaultFacotry()
.createNewLogger();

/**
* 将arg0数组，完全加在arg1的后面。
*
* @param arg0
* @param arg1
* @return
*/
private static int[] addAll(int[] arg0, int[] arg1) {
int[] arg = new int[arg0.length + arg1.length];
for (int i = 0; i < arg0.length + arg1.length; i++) {
if (i < arg0.length)
arg[i] = arg0[i];
else
arg[i] = arg1[i - arg0.length];
}
return arg;
}

/**
* 检查括号是否正确使用。
*
* @param arg
* @return
*/
private static boolean CheckBracket(String arg) {
boolean bln = true;
if (SubStrCount(arg, "(") != SubStrCount(arg, ")")) {
bln = false;
}
if (bln) {
int[] lbracket = indexOf(arg, "(");
int[] rbracket = indexOf(arg, ")");
int length = lbracket.length;
// new ErrPrintArray(System.err).printArray(lbracket);
for (int i = 0; i < length; i++) {
bln &= lbracket[i] < rbracket[i];
}
}

return bln;
}

/**
* 检查表达式，并返回最终合格得表达式结果，如果无法返回合格得结果，将抛出异常。
*
* @param arg
* @throws Exception
* @return
*/
private static String CheckTExpression(String arg) throws Exception {
// / 检查符号前后是否存在空缺。
arg = Trim(arg);
// / 将%修改成/100的运算符。
arg = arg.replaceAll(TExpression.PERCENT, "/100");
if (!CheckBracket(arg))
throw new Exception("括号没有匹配或者使用不当，请检查！");
// / 在)(之间增加*符号。
arg = TrimBracket(arg);
// / 如果-号开头，那么就在前面增加一个FU
if (arg.substring(0, 1).equals("-")) {
arg = TExpression.FU + arg.substring(1, arg.length());
}
// / 如果+号开头，那么就去掉+号
if (arg.substring(0, 1).equals("-")) {
arg = arg.substring(1, arg.length());
}
// / 如果*/号开头，那么前面加一个1
else if (arg.substring(0, 1).equals("*")
|| arg.substring(0, 1).equals("/")) {
arg = arg.substring(1, arg.length());
} else if (arg.substring(0, 1).equals("^")) {
throw new Exception("～符号不能用在公式开头的位置！");
} else if (arg.substring(0, 1).equals("^")) {
throw new Exception("∧符号不能用在公式开头的位置！");
}
return arg;
}

public static String Do(String expression, boolean showProcess)
throws Exception {
String testStr = expression;
/**
* 检查字符串。
*/
String aa = null;
try {
aa = CheckTExpression(testStr);
} catch (Exception e) {
gLogger.error(e.getMessage(), e);
e.printStackTrace();
}
try {
String[] bb = TExpression.getVars(aa, DefaultVars);
int i = 0;
// 如果操作完的结果跟操作前相同，说明不需要继续运算
// 增加i，避免死循环。
while (bb.length != 0 && i < 10000) {
aa = doOperate(aa);
if (showProcess) {
gLogger.info(aa);
}
bb = TExpression.getVars(aa, DefaultVars);
if (!isNaN(TrimAllBracket(aa))) {
aa = TrimAllBracket(aa);
break;
}
i++;
}
aa = TrimAllBracket(aa);
} catch (Exception e) {
gLogger.error(e.getMessage(), e);
e.printStackTrace();
}
return aa;
}

/**
* 对整个公式进行单步运算。
*
* @param arg
* @return
* @throws Exception
*/
private static String doOperate(String arg) throws Exception {
String leftRLT = "";
String rightRLT = "";
String rlt = arg;
int[] rkfs = TExpression.indexOf(rlt, new String[]
{ ")", });
int[] lkfs = TExpression.indexOf(rlt, new String[]
{ "(", });
// 找到第一个)符号。
// // 如果一个都没有找到，那么直接对整个公式进行操作。
if (rkfs.length == 0) {
leftRLT = "";
rightRLT = "";
rlt = arg;
}
// // 否则，取（）中间的内容，进行操作。
else {
int firstRkf = rkfs[0];
// System.out.println(arg.substring(firstRkf - 1, firstRkf + 2));
// 找到与第一个）符号对应的（
int containsLkf = lkfs[0];
for (int i = 1; i < lkfs.length; i++) {
if (lkfs[i] > firstRkf)
break;
else
containsLkf = lkfs[i];
}
// System.out.println(arg.substring(containsLkf - 1, containsLkf +
// 2));
// 取得中间的串，并取得两端的串。
leftRLT = rlt.substring(0, containsLkf);
rightRLT = rlt.substring(firstRkf + 1, rlt.length());
rlt = rlt.substring(containsLkf + 1, firstRkf);
}
// System.out.println(rlt);
// 重新检查语法
rlt = CheckTExpression(rlt);

String[] vars = getVars(rlt, DefaultVars);
String[] ops = getOperates(rlt, DefaultVars);
if (1 == 2) {
return null;
}
// 找到^~的运算
// // 如果存在^符号而且不存在～，或者存在^符号而且存在～符号并且^符号在～符号之前，那么就先运算^符号。
else if ((rlt.indexOf("^") != -1 && rlt.indexOf("~") == -1)
|| (rlt.indexOf("^") != -1 && rlt.indexOf("~") != -1 && rlt
.indexOf("^") < rlt.indexOf("~"))) {
int index = indexOf(ops, "^");
String op = TExpression.POWER;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// // 如果存在～符号而且不存在^，或者存在～符号而且存在^符号并且～符号在^符号之前，那么就先运算～符号。
else if ((rlt.indexOf("~") != -1 && rlt.indexOf("^") == -1)
|| (rlt.indexOf("~") != -1 && rlt.indexOf("^") != -1 && rlt
.indexOf("~") < rlt.indexOf("^"))) {
int index = indexOf(ops, "~");
if (vars[index + 1].equals("0"))
throw new Exception("【严重错误】:开方数不能为零");
String op = TExpression.SQRT;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// 如果没有找到，那么找*/的运算
else if ((rlt.indexOf("*") != -1 && rlt.indexOf("/") == -1)
|| (rlt.indexOf("*") != -1 && rlt.indexOf("/") != -1 && rlt
.indexOf("*") < rlt.indexOf("/"))) {
int index = indexOf(ops, "*");
String op = TExpression.MULTIPLY;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// // 如果存在～符号而且不存在^，或者存在～符号而且存在^符号并且～符号在^符号之前，那么就先运算～符号。
else if ((rlt.indexOf("/") != -1 && rlt.indexOf("*") == -1)
|| (rlt.indexOf("/") != -1 && rlt.indexOf("*") != -1 && rlt
.indexOf("/") < rlt.indexOf("*"))) {
int index = indexOf(ops, "/");
if (vars[index + 1].equals("0"))
throw new Exception("【严重错误】:除数为零");
String op = TExpression.DIVIDE;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// 如果没有找到，那么找+-运算
else if ((rlt.indexOf("+") != -1 && rlt.indexOf("-") == -1)
|| (rlt.indexOf("+") != -1 && rlt.indexOf("-") != -1 && rlt
.indexOf("+") < rlt.indexOf("-"))) {
int index = indexOf(ops, "+");
String op = TExpression.ADD;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// // 如果存在～符号而且不存在^，或者存在～符号而且存在^符号并且～符号在^符号之前，那么就先运算～符号。
else if ((rlt.indexOf("-") != -1 && rlt.indexOf("+") == -1)
|| (rlt.indexOf("-") != -1 && rlt.indexOf("+") != -1 && rlt
.indexOf("-") < rlt.indexOf("+"))) {
int index = indexOf(ops, "-");
String op = TExpression.DECREASE;
rlt = doOperate1(rlt, vars[index], vars[index + 1], op);
rlt = "(" + rlt + ")";
}
// // 如果什么符号都没有找到，说明该串是个单变量的串，直接去掉两端的括号，返回。
else {
rlt = TrimAllBracket(rlt);
}
// 把运算结果替换到适当的位置，然后返回。
return leftRLT + rlt + rightRLT;
}

/**
* 执行某个运算操作。
*
* @param vars
* @param ops
* @param op
*            如："\\\\*"
* @return
* @throws Exception
*/
private static String doOperate1(String rlt, String var1, String var2,
String op) throws Exception {
String tmp = var1 + op + var2;
if (var1.indexOf(TExpression.FU) != -1) {
var1 = var1.replaceAll(TExpression.FU, "-");
}
if (!isNaN(var1) && !isNaN(var2)) {
// System.out.println(tmp);
rlt = rlt.replaceFirst(tmp, "" + operate(var1, var2, op));
}
rlt = "(" + rlt + ")";
return rlt;
}

/**
* 返回int数组中最小的一个。 假设数组中不存在相等的情况。
*
* @param arg
* @return
*/
private static int getMin(int[] arg, int fromIndex) throws Exception {
int i = arg[fromIndex];
for (int k = fromIndex + 1; k < arg.length; k++) {
if (arg[k] < i) {
i = arg[k];
} else if (arg[k] == i && arg[k] != Integer.MAX_value)
throw new Exception("数组中存在相等的值，无法进行取最小值的运算。");
}
return i;
}

/**
* 返回arg1中在arg2数组中存在的所有变量的顺序组合。 如 (5*4+3) 返回 {*,+} ;
*
* @param arg1
* @param arg2
* @return
* @throws Exception
*/
private static String[] getOperates(String arg1, String[] arg2)
throws Exception {
int[] indexs = indexOf(arg1, arg2);
String[] ops = new String[indexs.length];
for (int i = 0; i < indexs.length; i++) {
ops[i] = arg1.substring(indexs[i], indexs[i] + 1);
}
return ops;
}

/**
* 返回arg1中在arg2数组中存在的所有变量两端的变量的顺序组合。 如 (5*4+3) 返回 {5,4,3} ;
*
* @param arg1
* @param arg2
* @return
* @throws Exception
*/
private static String[] getVars(String arg1, String[] arg2)
throws Exception {
// 去掉所有括号。
arg1 = arg1.replaceAll(TExpression.LBRACKET, "");
arg1 = arg1.replaceAll(TExpression.RBRACKET, "");

int[] indexs = indexOf(arg1, arg2);
// 如果没有运算符，那么返回本身。
if (indexs.length == 0)
return new String[]
{ arg1 };
String[] vars = new String[indexs.length + 1];
for (int i = 0; i < indexs.length + 1; i++) {
if (i == 0)
vars[i] = arg1.substring(0, indexs[i]);
else if (i == indexs.length)
vars[i] = arg1.substring(indexs[i - 1] + 1, arg1.length());
else
vars[i] = arg1.substring(indexs[i - 1] + 1, indexs[i]);
}
return vars;
}

/**
* 取得arg0中arg1的所有索引的值。
*
* @param arg0
* @param arg1
* @return
*/
private static int[] indexOf(String arg0, String arg1) {
int i = 0;
int j = 0;
int[] intArr = new int[SubStrCount(arg0, arg1)];
while (arg0.indexOf(arg1, i) != -1) {
intArr[j] = arg0.indexOf(arg1, i);
i = intArr[j] + 1;
j++;
}
return intArr;
}

/**
* 取得arg0中arg1[]任意一个的所有索引的值。
*
* @param arg0
* @param arg1
* @return
*/
private static int[] indexOf(String arg0, String[] arg1) throws Exception {
int j = 0;
// 取得arg1中所有成员最近的位置。
int[] targets = new int[0];
for (int k = 0; k < arg1.length; k++) {
targets = addAll(targets, indexOf(arg0, arg1[k]));
}
Arrays.sort(targets);
int[] intArr = new int[targets.length];
while (j < intArr.length) {
// 取得最近的一个成员的位置。
int target = getMin(targets, j);
intArr[j] = target;
j++;
}
return intArr;
}

/**
* 返回字串数组中，相关值对应的索引。
*
* @param arg1
* @param arg2
* @return
*/
private static int indexOf(String[] arg1, String arg2) {
for (int i = 0; i < arg1.length; i++) {
if (arg2.equals(arg1[i]))
return i;
}
return -1;
}

/**
* 判断是否为数字。
*
* @param arg
* @return
*/
private static boolean isNaN(String arg) {
if (arg == null || arg.length() == 0)
return true;
try {
Double.parseDouble(arg);
} catch (NumberFormatException e) {
return true;
}
return false;
}

public static void main(String[] args) {
String testStr = "((-1-2%*3^(4)~2/1)(7+8)-9)()";
testStr = "150*(200-600/40)*12+14*3-55+76+23/3+5+5";
// testStr = "150*(200-600/40)*12+14*3-55+76+23/3+5+5/0";
// System.err.println(testStr);

// System.out.println("gdasfds");
// System.out.println("gdasfds".replaceAll("k", ""));
// System.out.println(SubStrCount(testStr, "~"));
// System.out.println("gdass".indexOf("k"));
// new
// ErrPrintArray(System.err).printArray(TExpression.indexOf("fagaxa",
// "a"));
/**
* 检验括号是否正确。
*/
// boolean kk = CheckBracket(testStr);
// System.err.println(kk);
/**
* 获得字符串中所有变量的顺序组合。
*/
try {
// new ErrPrintArray(System.err).printArray(TExpression.getVars(aa,
// new String[] { "+", "-", "*", "/", "^", "~", }));
} catch (Exception e) {
e.printStackTrace();
}
/**
* 正式测试功能。
*/
try {
testStr = Do(testStr, true);
} catch (Exception e) {
e.printStackTrace();
}
System.err.println(testStr);
}

/**
* 直接运算得到结果。
*
* @param arg1
* @param arg2
* @param op
* @return
* @throws Exception
*/
private static double operate(String arg1, String arg2, String op)
throws Exception {
double a1 = Double.parseDouble(arg1);
double a2 = Double.parseDouble(arg2);
if (op.equals(TExpression.ADD)) {
return a1 + a2;
} else if (op.equals(TExpression.DECREASE)) {
return a1 - a2;
} else if (op.equals(TExpression.MULTIPLY)) {
return a1 * a2;
} else if (op.equals(TExpression.DIVIDE)) {
return a1 / a2;
} else if (op.equals(TExpression.SQRT)) {
return Math.pow(a1, 1 / a2);
} else if (op.equals(TExpression.POWER)) {
return Math.pow(a1, a2);
}
return 0d;
}

/**
* 返回arg0中包含的arg1的个数。
*
* @param arg0
* @param arg1
* @return
*/
private static int SubStrCount(String arg0, String arg1) {
int i = 0;
arg0 = Trim(arg0);
i = arg0.length();
arg1 = arg1.replaceAll("\\\\+", "\\\\" + ADD);
arg1 = arg1.replaceAll("\\\\-", "\\\\" + TExpression.DECREASE);
arg1 = arg1.replaceAll("\\\\*", "\\\\" + TExpression.MULTIPLY);
arg1 = arg1.replaceAll("\\\\^", "\\\\" + TExpression.POWER);
arg1 = arg1.replaceAll("\\\\(", "\\\\" + TExpression.LBRACKET);
arg1 = arg1.replaceAll("\\\\)", "\\\\" + TExpression.RBRACKET);
i = i - arg0.replaceAll(arg1, "").length();
return i;
}

/**
* 去除所有包含的空格。
*
* @param arg
* @return
*/
private static String Trim(String arg) {
String rlt = "";
rlt = arg.replaceAll(" ", "");
return rlt;
}

/**
* 去掉字串中的所有),(符号。
*
* @param arg
* @return
*/
private static String TrimAllBracket(String arg) {
String rlt = arg;
rlt = rlt.replaceAll("\\\\(", "");
rlt = rlt.replaceAll("\\\\)", "");
return rlt;
}

/**
* 去掉多余的()符号； 在)(之间增加*符号；
*
* @param arg
* @return
*/
private static String TrimBracket(String arg) {
String rlt = arg;
rlt = rlt.replaceAll("\\\\(\\\\)", "");
rlt = rlt.replaceAll("\\\\)\\\\(", "\\\\)\\\\*\\\\(");
return rlt;
}
}

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

import cn.com.worksoft.util.basetype.CastType;

/**
* @author XING 日期时间工具类。
*/
public final class TDateTime implements java.io.Serializable, Comparable {
private final static int[] full_day_month = new int[] { 1, 3, 5, 7, 8, 10,
12 };

/**
* The year of the gregorianCutover, with 0 representing 1 BC, -1
* representing 2 BC, etc.
*/
private static transient int gregorianCutoverYear = 1582;

private final static int[] normal_day_month = new int[] { 4, 6, 9, 11};

public final static int QUARTER_OF_FIRST = 1;

public final static int QUARTER_OF_FOURTH = 4;

public final static int QUARTER_OF_SECOND = 2;

public final static int QUARTER_OF_THIRD = 3;

/**
*
*/
private static final long serialVersionUID = 1574586998788149344L;

/**
* 当前日期时间。
*
* @return
*/
public static TDateTime CurrentDateTime() {
return new TDateTime();
}

/**
* 取得某年月最大日。
*
* @param y
* @param m
* @return
*/
public static int getMaxDay(int y, int m) {
if (isLeapNormalMonth(y, m))
return 29;
else if (isNormalMonth(y, m))
return 28;
else if (isSmallMonth(m))
return 30;
else
return 31;
}

/**
* 是否为大月
*
* @param m
* @return
*/
public static boolean isBigMonth(int m) {
for (int i = 0; i < full_day_month.length; i++) {
if (m == full_day_month[i])
return true;
}
return false;
}

/**
* 是否为闰平月
*
* @param year
* @param month
* @return
*/
public static boolean isLeapNormalMonth(int y, int m) {
return isleapyear(y) && m == 2;
}

/**
* 是否闰年。
*
* @param y
* @return
*/
public static boolean isleapyear(int y) {
return y >= gregorianCutoverYear ? ((y % 4 == 0) && ((y % 100 != 0) || (y % 400 == 0)))
: // Gregorian
(y % 4 == 0); // Julian
}

/**
* 是否为普通平月
*
* @param year
* @param month
* @return
*/
public static boolean isNormalMonth(int y, int m) {
return !isleapyear(y) && m == 2;
}

/**
* 是否为小月
*
* @param m
* @return
*/
public static boolean isSmallMonth(int m) {
for (int i = 0; i < normal_day_month.length; i++) {
if (m == normal_day_month[i])
return true;
}
return false;
}

public static void main(String[] args) throws Exception {
// System.out.println(CastType.dtparse("2005-3-3 00:00:00"));
TDateTime tdt1 = new TDateTime("2005-3-32 10:00:00");
TDateTime tdt2 = new TDateTime("2005-4-1 11:00:00");
// TDateTime tdt1 = new TDateTime(2000, 2, 3, 4, 5, 6, 7);
System.out.println(tdt1);
System.out.println(tdt2);
System.out.println(tdt1.getDayDistance(tdt2));
System.out.println(tdt1);
System.out.println(tdt2);
}

private Calendar cal = null;

private Date dt = null;

private Timestamp ts = null;

public TDateTime() {
cal = Calendar.getInstance();
dt = cal.getTime();
ts = new Timestamp(cal.getTimeInMillis());
}

public TDateTime(Calendar cal) {
init(cal);
}

public TDateTime(Date dt) {
init(dt);
}

public TDateTime(int year) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
init(cal);
}

public TDateTime(int year, int month) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
init(cal);
}

public TDateTime(int year, int month, int day) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, day);
init(cal);
}

public TDateTime(int year, int month, int day, int hour) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, day);
cal.set(Calendar.HOUR_OF_DAY, hour);
init(cal);
}

public TDateTime(int year, int month, int day, int hour, int minute) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, day);
cal.set(Calendar.HOUR_OF_DAY, hour);
cal.set(Calendar.MINUTE, minute);
init(cal);
}

public TDateTime(int year, int month, int day, int hour, int minute,
int second) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, day);
cal.set(Calendar.HOUR_OF_DAY, hour);
cal.set(Calendar.MINUTE, minute);
cal.set(Calendar.SECOND, second);
init(cal);
}

public TDateTime(int year, int month, int day, int hour, int minute,
int second, int millisecond) {
cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, day);
cal.set(Calendar.HOUR_OF_DAY, hour);
cal.set(Calendar.MINUTE, minute);
cal.set(Calendar.SECOND, second);
cal.set(Calendar.MILLISECOND, millisecond);
init(cal);
}

public TDateTime(String value) throws Exception {
this(CastType.dtparse(value));
}

public TDateTime(TDateTime tdt) {
cal = (Calendar) tdt.cal.clone();
init(cal);
}

public TDateTime(Timestamp ts) {
init(ts);
}

/**
* 增加日期。
*
* @param add
*/
public void addDay(int add) {
cal.add(Calendar.DATE, add);
init(cal);
}

/**
* 增加小时。
*
* @param add
*/
public void addHour(int add) {
cal.add(Calendar.HOUR_OF_DAY, add);
init(cal);
}

/**
* 增加毫秒。
*
* @param add
*/
public void addMillisecond(int add) {
cal.add(Calendar.MILLISECOND, add);
init(cal);
}

/**
* 增加分钟。
*
* @param add
*/
public void addMinute(int add) {
cal.add(Calendar.MINUTE, add);
init(cal);
}

/**
* 增加月。
*
* @param add
*/
public void addMonth(int add) {
cal.add(Calendar.MONTH, add);
init(cal);
}

/**
* 增加秒。
*
* @param add
*/
public void addSecond(int add) {
cal.add(Calendar.SECOND, add);
init(cal);
}

/**
* 增加年份。
*
* @param add
*/
public void addYear(int add) {
cal.add(Calendar.YEAR, add);
init(cal);
}

/*
* (non-Javadoc)
*
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
public int compareTo(Object o) {
if (o == null) {
return 1;
}
if (o instanceof TDateTime) {
return compareTo((TDateTime) o);
}
throw new UnknowRuntimeException("can't compare TDateTime with "
+ o.getClass());
}

public int compareTo(TDateTime tdt) {
if (tdt == null) {
return 1;
}
return dt.compareTo(tdt.dt);
}

/**
* 取得Calendar数据。
*
* @return
*/
public Calendar getCalendar() {
return cal;
}

/**
* 取得Date数据。
*
* @return
*/
public Date getDate() {
return dt;
}

/**
* 取得日期。
*
* @return Returns the day.
*/
public int getDay() {
return cal.get(Calendar.DATE);
}

/**
* 取得两个日期相隔天数。 <br>
* 如果比参数日大，返回正数，否则如果小，返回负数，否则返回零。
*
* @param tdt
* @return
*/
public int getDayDistance(TDateTime tdt) {
tdt = new TDateTime(tdt);
TDateTime clone = new TDateTime(this);
clone.setHour(0);
clone.setMinute(0);
clone.setSecond(0);
clone.setMillisecond(0);
tdt.setHour(0);
tdt.setMinute(0);
tdt.setSecond(0);
tdt.setMillisecond(0);

int day = 0;
if (clone.compareTo(tdt) > 0) {
while (clone.compareTo(tdt) > 0) {
day++;
clone.addDay(-1);
}
} else {
while (clone.compareTo(tdt) < 0) {
day--;
clone.addDay(1);
}
}
return day;
}

/**
* 取得小时。
*
* @return Returns the hour.
*/
public int getHour() {
return cal.get(Calendar.HOUR_OF_DAY);
}

/**
* 取得本月最大天数。
*
* @return
*/
public int getMaxDay() {
return getMaxDay(getYear(), getMonth());
}

/**
* 取得毫秒。
*
* @return Returns the millisecond.
*/
public int getMillisecond() {
return cal.get(Calendar.MILLISECOND);
}

/**
* 取得分钟。
*
* @return Returns the minute.
*/
public int getMinute() {
return cal.get(Calendar.MINUTE);
}

/**
* 取得月份。
*
* @return Returns the month.
*/
public int getMonth() {
return cal.get(Calendar.MONTH) + 1;
}

/**
* 取得季节。
*
* @return
*/
public int getQuarter() {
int month = getMonth();
switch (month) {
case 1:
case 2:
case 3:
return TDateTime.QUARTER_OF_FIRST;
case 4:
case 5:
case 6:
return TDateTime.QUARTER_OF_SECOND;
case 7:
case 8:
case 9:
return TDateTime.QUARTER_OF_THIRD;
case 10:
case 11:
case 12:
return TDateTime.QUARTER_OF_FOURTH;
}
throw new UnknowRuntimeException("month is error");
}

/**
* 取得秒。
*
* @return Returns the second.
*/
public int getSecond() {
return cal.get(Calendar.SECOND);
}

/**
* 获得Timestamp类型数据。
*
* @return
*/
public Timestamp getTimestamp() {
return ts;
}

/**
* 取得年。
*
* @return Returns the year.
*/
public int getYear() {
return cal.get(Calendar.YEAR);
}

/**
* @param c
*/
private void init(Calendar c) {
cal = c;
dt = cal.getTime();
ts = new Timestamp(cal.getTimeInMillis());
}

/**
* @param d
*/
private void init(Date d) {
dt = d;
ts = new Timestamp(d.getTime());
cal = Calendar.getInstance();
cal.setTimeInMillis(ts.getTime());
}

/**
* @param t
*/
private void init(Timestamp t) {
ts = t;
cal = Calendar.getInstance();
cal.setTimeInMillis(ts.getTime());
dt = cal.getTime();
}

/**
* 设置日期。
*
* @param day
*            The day to set.
*/
public void setDay(int day) {
cal.set(Calendar.DATE, day);
init(cal);
}

/**
* 设置小时。
*
* @param hour
*            The hour to set.
*/
public void setHour(int hour) {
cal.set(Calendar.HOUR_OF_DAY, hour);
init(cal);
}

/**
* 设置毫秒。
*
* @param millisecond
*            The millisecond to set.
*/
public void setMillisecond(int millisecond) {
cal.set(Calendar.MILLISECOND, millisecond);
init(cal);
}

/**
* 设置分钟。
*
* @param minute
*            The minute to set.
*/
public void setMinute(int minute) {
cal.set(Calendar.MINUTE, minute);
init(cal);
}

/**
* 设置月份。
*
* @param month
*            The month to set.
*/
public void setMonth(int month) {
cal.set(Calendar.MONTH, month - 1);
init(cal);
}

/**
* 设置秒。
*
* @param second
*            The second to set.
*/
public void setSecond(int second) {
cal.set(Calendar.SECOND, second);
init(cal);
}

/**
* 设置年。
*
* @param year
*            The year to set.
*/
public void setYear(int year) {
cal.set(Calendar.YEAR, year);
init(cal);
}

/**
* 返回日期串。
*
* @return
*/
public String toDateString() {
return toString("yyyy-MM-dd");
}

/**
* 返回日期时间串
*
* @return
*/
public String toDateTimeString() {
return toString("yyyy-MM-dd HH:mm:ss.SSS");
}

/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("TDateTime");
sb.append("[");
sb.append(getTimestamp());
sb.append("]");
sb.append("[");
sb.append("Year:");
sb.append(getYear());
sb.append(",");
sb.append("Month:");
sb.append(getMonth());
sb.append(",");
sb.append("Day:");
sb.append(getDay());
sb.append(",");
sb.append("Hour:");
sb.append(getHour());
sb.append(",");
sb.append("Minute:");
sb.append(getMinute());
sb.append(",");
sb.append("Second:");
sb.append(getSecond());
sb.append(",");
sb.append("MilliSecond:");
sb.append(getMillisecond());
sb.append("]");
return sb.toString();
}

/**
* <pre>
*                              时间格式语法：
*                        
*                              使用一个 time pattern 字符串指定时间格式。 在这种方式下，所有的 ASCII 字母被保留为模式字母，定义如下：
*                        
*                              符号     含义                    表示                示例
*                              ------   -------                 ------------        -------
*                              G        年代标志符              (Text)              AD
*                              y        年                      (Number)            1996
*                              M        月                      (Text & Number)     July & 07
*                              d        日                      (Number)            10
*                              h        时 在上午或下午 (1˜12)  (Number)            12
*                              H        时 在一天中 (0˜23)      (Number)            0
*                              m        分                      (Number)            30
*                              s        秒                      (Number)            55
*                              S        毫秒                    (Number)            978
*                              E        星期                    (Text)              Tuesday
*                              D        一年中的第几天          (Number)            189
*                              F        一月中第几个星期几      (Number)            2  (2nd Wed in July)
*                              w        一年中第几个星期        (Number)            27
*                              W        一月中第几个星期        (Number)            2
*                              a        上午 / 下午 标记符      (Text)              PM
*                              k        时 在一天中 (1˜24)      (Number)            24
*                              K        时 在上午或下午 (0˜11)  (Number)            0
*                              z        时区                    (Text)      Pacific Standard Time
*                              '        文本转义符              (Delimiter)
*                              ''       单引号                  (Literal)           '
* </pre>
*
* @param parttern
* @return
*/
/**
* @param parttern
* @return
*/
public String toString(String parttern) {
SimpleDateFormat sdf = new SimpleDateFormat(parttern);
return sdf.format(dt);
}

/**
* 返回短时间类型。
*
* @return
*/
public String toShortTimeString() {
return toString("HH:mm");
}

/**
* 返回时间串。
*
* @return
*/
public String toTimeString() {
return toString("HH:mm:ss.SSS");
}
}

2、是否购买或者使用了一些信息化系统软件，如专卖店销售系统，订单系统等，这些系统有哪些人员使用，他们掌握的相关计算机知识如何？

3、业务构成是怎样的？是否分别由不同的负责人管理？是如何分配的？

4、目前业务流程图中包含了××，××，××等一系列的业务，是否这些业务都要纳入？

5、结帐时是否存在与银行转帐接口？

6、部分服务人员工作环境无法直接使用电脑，是否需要其他设备参与？如PDA或者其他手持设备等？

7、客户希望什么时候能组织开发、实施该系统？预计覆盖的业务属于（极大、大、一般、中小，小）的哪一种？预算大致是多少？，以及涵盖得范围。

8、客户对实现技术，售后服务等有没有特殊需求？

针对以上内容的了解，
第一方面，可以大致了解项目的范围，投入和实现技术；
第二方面，可以了解用户群体的基本情况；
第三方面，可以估计实现难度。

夏本是一个古老的部落，相传是由包括夏在内的十多个部落联合发展而来的，与古代其他部落交错分布于中国境内。到唐尧、虞舜时期，夏族的首领禹因治水有功，取得了帝位，并传给其子启，从而建立了我国历史上第一个奴隶制王朝。夏王朝约存在于公元前二十一世纪至公元前十六世纪。

第一节，        历史介绍

夏是我国历史上有记载的最早的朝代，之前的历史信息都是基于民间传说和演绎分析而来，但是从夏开始，就已经有了许多史实资料可以研究了。整个夏王朝的历史经历了夏禹、启、太康、中康、相、少康、予、槐、芒、泄、不降、帝扃（ｊｉ ō ｎｇ，平声炯）、廑（ｊ ǐ ｎ，谨）、孔甲、皋、发、履癸（就是桀）。从孔甲开始，各诸侯相继背弃天子，夏王朝也开始走向衰落。

在夏所有天子中，最知名、最伟大的，就是大禹。他拥有神话般的传奇经历，和非常人的本领。在舜统治时期，他制定了地方赋税制度，在全国范围内掀起治水运动，为国家的经济、文化、军事等的发展奠定了基础。他采取的蓄水、疏导等多种科学的治水策略，为后人提供的丰富的水利经验，至今仍然被水利相关部门采用。另外，他身先士卒，以德服天下，最终继承了帝位，统领了天下。他究竟是怎么治山治水的呢，我们来了解一下吧：

首先他命令诸候将各地劳役犯调来集中修筑堤防，而他自己带着一支队伍，翻山越岭，进行地图绘制，并分别做了标记和命名。他注重勤俭节约，自己住的也是土屋。同时，他每到一处，就给当地的百姓发放粮食种子，让他们种田种地，有饭吃。同时他也规定每家每户的上交任务作为国家财政收入。并亲自分析指定上交贡赋的路线。他的治水工作不是自上而下地颁布所谓的上级指示，而是从小处着手，从基层干起。他的治水工作从都城冀州壶口工程开始，然后走向山西太原地区，然后再到太岳山地区，再之后是覃怀、衡水、漳水等。在治理过程中，他根据地方水土质量，为各类粮食经济作物定等级，并设定不同的赋税制度，随着治理工作的持续推进，水土质量上来，人民生活也得到了提高，同时他也修好了新的进贡路线，方便运送进贡物资。另外，这些进贡路线的开辟，也为各地交通运输和文化交流提供了通道。他把相对平坦的地区，开发成肥沃的平原，为老百姓提供了生存发展的有利场所。经过治理的大河大湖，在多雨的季节，水流也不再四处蔓延，相反还为农牧业的灌溉提供了丰富的水储备。在大禹继位之前，他的德行深深打动了一个人的心，那就是皋陶，皋陶同时推行德政的实施，将他的影响进一步扩大，为他今后的发展提供了很大的帮助。

大禹是一个开明的君主，他任用贤能，并坚决不把位置传给自己的儿子启，而传给了益，然而益的影响太小，在众人的压力下，把位置传给了大禹的儿子启。启登位后，第一件事情就是巩固自己的统治，他率军队在甘地同扈氏大打一战。于是天下都臣服朝拜。

第二节，        项目管理相关分析

前不久，看教育频道的电视，里面有一段针对娱乐经济的概念的阐述，是这么说的，娱乐经济有四个层面的理解，第一个层面，就是狭义的娱乐经济，如音乐、电影等传统的娱乐产业。

第二个层面，是增加了的新型娱乐项目的娱乐经济，诸如服务业、媒体等等。第三个层面，是泛娱乐经济，诸如体育、文化教育等等。第四个层面，就是一切都是娱乐经济。这不禁让我想到项目管理的概念，我想项目管理说小也小，小到一次采购，哪怕是购买一个冰激凌，说大也大，大到一个国家乃至地球的治理。

很明显，大禹是个项目管理的老手，首先他明白，这么大的一个项目，不可能是一蹴而就的，第一，项目的存活是关键，于是，他先在离都城冀州不远的壶口，搞了一个不大不小的工程，这样，为项目的运转拉到了第一笔资金，得到了政府部门的认可和支持。同时，他乘胜追击，又接二连三的完成了一个又一个的“小”工程项目，这个时候，他已经懂得以战养战的理念，这样，政府的付出，也就有了回报，各地条件得到改善的居民，根据他的要求上交更多的进贡赋税。而他也从这些进贡中抽取一部分作为今后的新的工程款。我们的很多项目管理者，都在抱怨自己总是投身于小的项目当中，可是有一点最关键没有弄明白的就是这个“以战养战”的思想。

大禹第二个做得很好的，就是并非任用最优秀的人才。“治水”项目刚起步的时候，大禹没办法要求舜帝提供更多的人才支持，所以，他需要合理使用政府拨款，而被罚的苦劳役犯人，应当说是最廉价的人了。所以一方面，他提升核心团队的技术水平和技术积累，甚至亲自参与地图考察和绘制，另一方面，却大胆使用廉价劳动力资源。在降低生产成本方面，这也是值得在当前社会上我们的新型项目管理者广泛注意的。

第三，大力发展边缘经济，大禹治水自有一套，但是他绝对不拘泥于此，首先，他也搞治山，就是开辟山路，搞活交通，以便发展经济，也方便进贡啊。，其次，他大力推动发展地方经济，鼓励自主创业，自己提升。提升对他有什么用啊，干活多、进贡多呗。同时，他还制定了一些量测标准，如长度、面积等等。他还推进各类经济产业的发展，如皮毛纺织、奢侈品工艺等等。与其说这些都跟治水有关，还不如大禹充当了一个国家领导人的角色。他的丰功伟绩，为他以后的登基奠定了基石。所以，他的继位，也是理说当然的。

第三节，        小结

大禹治水项目，给我们的提示很多，他不仅仅是一个优秀的项目管理者，他在这 13 年的锻炼中，成功的从一个项目管理者成长为一个国家领导者。这也许是项目管理者的终极目标。我们从这个项目中，还体会到，项目管理里面也包含有经济上的管理，有时候甚至影响了项目的成败，你看看，任用廉价人员，发展边缘经济等等，哪怕是选择项目方向，都要基于项目的未来发展而立足于当前，才能不败。这也是我最佩服大禹之所在。