java时间公用和StringUnitl以及java调用存储过程

1 构建存储过程的语句信息

/**
* 从Function名称和参数信息拼接数据库存储过程访问SQL语句
* 示例：
* {?= call f_conf_qr_queryallconfig(?, ?, ?, ?, ?, ?, ?, ?)}
* @param funcName Function名称
* @param params 参数信息
* @return 数据库存储过程访问SQL语句
*/
String buildRunSql(final String funcName, final Object[][] params)
{
final StringBuffer buffer = new StringBuffer();
buffer.append(WorkerKeys.LEFT_BRACKET);
//拼接Oracle的function返回值处理
buffer.append(WorkerKeys.WENHAO).append(WorkerKeys.EQUAL_MARK);
buffer.append(WorkerKeys.DB_CALL_MARK).append(funcName);
if (null != params)
{
//参数部分字符串 (?, ?, ?)
buffer.append(WorkerKeys.LEFT_GUAHAO);
for (int i = 0; i < params.length; i++)
{
buffer.append(0 == i ? DaoKeys.EMPTY : WorkerKeys.COMMA_BLANK);
buffer.append(WorkerKeys.WENHAO_STR);
}
buffer.append(WorkerKeys.RIGHT_GUAHAO);
}
buffer.append(WorkerKeys.RIGHT_BRACKET);
return buffer.toString();
}

2 调用存储过程信息
String[][] params = new String[][] {
{DaoKeys.IN_STR, DaoKeys.VARCHAR, phoneNumber}, //电话号码
{DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getTonecode()}, //铃音编码
{DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getPurchase()}, //订购时间
{DaoKeys.OUT_STR, DaoKeys.INTEGER, DaoKeys.EMPTY}}; //返回码
String runSql = buildRunSql("",params);
CallableStatement callableStatement = Connection.prepareCall(runSql);
callableStatement.execute();

==================================================================
/*
* 文 件 名: TimeUtils.java
* 版 权: Huawei Technologies Co., Ltd. Copyright YYYY-YYYY, All rights reserved
* 描 述: 时间工具类
* 修 改 人: w00106790
* 修改时间: 2012-03-08
* 修改版本: COMMON V1.0
* 修改内容: 新增
*
* 修改人：王顺
* 修改内容：新增getDBTimeOnceADay方法
* 修改时间： 2012-08-21
*/
package com.huawei.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

import com.huawei.common.constants.TimeKeys;
import com.huawei.common.system.action.SystemActions;


public final class TimeUtils
{
/**
* 时间正则表达式与格式对应关系
*/
private static final String[][] COM_PATTERNS = new String[][]{
new String[]{TimeKeys.REGEX_YYYY_MM_DD, TimeKeys.YYYY_MM_DD},
new String[]{TimeKeys.REGEX_YYYY_MM_DD_HH_MM_SS, TimeKeys.YYYY_MM_DD_HH_MM_SS},
new String[]{TimeKeys.REGEX_YYYYMMDD, TimeKeys.YYYYMMDD},
new String[]{TimeKeys.REGEX_YYYYMMDDHHMMSS, TimeKeys.YYYYMMDDHHMMSS},
new String[]{TimeKeys.REGEX_HH_MM_SS, TimeKeys.HH_MM_SS}
};

/**
* 特殊时间正则表达式与格式对应关系
*/
private static final String[][] SPECIAL_PATTERNS = new String[][]{
//调用中音的qryUserTone的时候有些局点返回的时间格式是yyyy.MM.dd
new String[]{TimeKeys.REGEX_YYYY_MM_DD_EX1, TimeKeys.YYYY_MM_DD_EX1}
};

/**
* 数据库时间获取器
*/
private static final DBTimeGetter DAILY_GETTER = new DBTimeGetter(TimeKeys.DAY_MILLIS);

/**
* 工具类，私有化构造方法
*/
private TimeUtils()
{

}

/**
* 对输入时间进行加法操作（因子可以为负数，此时表减法）
* @param inputTime 输入时间
* @param field 加法类型
* 1、Calendar.MONTH 按月份
* 2、Calendar.DATE 按天
* 3、Calendar.MINUTE --按分钟
* @param amount 增加幅度 负数则为减法
* @return 加法后的时间
*/
public static long addTime(long inputTime, int field, int amount)
{
//日期方法
final Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date(inputTime));
calendar.add(field, amount);
return calendar.getTimeInMillis();
}

/**
* 在原有日期上加上指定天数
* @param inputTimeStr 原来日期String型
* @param timePattern 时间格式
* @param field 加法类型
* 1、Calendar.MONTH 按月份
* 2、Calendar.DATE 按天
* 3、Calendar.MINUTE --按分钟
* @param amount 增加幅度 负数则为减法
* @return date
*/
public static String addTime(String inputTimeStr, String timePattern, int field, int amount)
{
//获取输入时间的长整型值
long inputTime;
try
{
inputTime = parseTimeInMillis(inputTimeStr, timePattern);
}
catch (ParseException e1)
{
return null;
}

//获取时间加减后的值
long addedInputTime = addTime(inputTime, field, amount);

//对时间进行字符串格式化
return formatTime(addedInputTime, timePattern);
}

/**
* 获取当前时间是否在约定的开始结束时间之间
* @param beginTime 开始时间
* @param endTime 结束时间
* @return 是否在约定时间内
* @throws ParseException 解析异常信息
*/
public static boolean isThisTimeBetween(String beginTime, String endTime) throws ParseException
{
//时间格式器
final SimpleDateFormat format = new SimpleDateFormat(TimeKeys.HH_MM_SS);

//解析开始结束时间并获取当前时间
final long beginTimeL = format.parse(beginTime).getTime();
final long endTimeL = format.parse(endTime).getTime();
final long thisTimeL = format.parse(format.format(new Date())).getTime();

//返回当前时间是否在两者之间
return (thisTimeL >= beginTimeL) && (thisTimeL <= endTimeL);
}

/**
* 数据库时间格式转换
* @param inputTime 字符串时间
* @return long型时间
* @throws ParseException 解析异常
*/
public static long parseTimeInMillis(String inputTime) throws ParseException
{
//默认不支持特殊格式的时间格式
return parseTimeInMillis(inputTime, false);
}

/**
* 数据库时间格式转换
* @param inputTime 字符串时间
* @param specialPattern 特殊格式
* @return long型时间
* @throws ParseException 解析异常
*/
public static long parseTimeInMillis(String inputTime, boolean specialPattern) throws ParseException
{
//判断输入时间是否为空，为空直接返回码
if (StringUtils.isBlank(inputTime))
{
throw new ParseException("Empty param value input!", 0);
}

//根据输入时间获取格式
String pattern = getTimePattern(inputTime, TimeKeys.HH_MM_SS, specialPattern);

//解析
return parseTimeInMillis(inputTime, pattern);
}

/**
* 格式化字符串时间
* @param inputTime 字符串时间
* @param pattern 格式类型
* @return 格式化后的时间（long型）
* @throws ParseException 格式化异常
*/
public static long parseTimeInMillis(String inputTime, String pattern) throws ParseException
{
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);

//格式化字符串
final Date inputDate = dateFormat.parse(inputTime);

//格式化字符串
return inputDate.getTime();
}

/**
* 根据时间值获取时间格式
* @param inputTime 时间的值
* @param defPattern 默认格式
* @param specialPattern 特殊格式
* @return 时间格式
*/
private static String getTimePattern(String inputTime, String defPattern, boolean specialPattern)
{
//循环列表进行判断处理
int length = COM_PATTERNS.length;
for (int i = 0; i < length; i++)
{
//判断是否匹配正则表达式
if (inputTime.matches(COM_PATTERNS[i][0]))
{
return COM_PATTERNS[i][1];
}
}

//不包括特殊格式则直接返回
if (!specialPattern)
{
return defPattern;
}

//循环遍历特殊格式列表
length = SPECIAL_PATTERNS.length;
for (int i = 0; i < length; i++)
{
//判断是否匹配正则表达式
if (inputTime.matches(SPECIAL_PATTERNS[i][0]))
{
return SPECIAL_PATTERNS[i][1];
}
}

//其他情况返回默认值
return defPattern;
}

/**
* 将Long型时间转换为字符串
* @param inputTime long型时间
* @param pattern 类型
* @return 返回字符串时间
*/
public static String formatTime(long inputTime, String pattern)
{
//返回格式化后的字符串时间
return new SimpleDateFormat(pattern).format(new Date(inputTime));
}

/**
* 将某格式字符串类型时间转换为另一个格式字符串
* @param inputTime 字符串型时间
* @param inputPattern 输入时间的格式
* @param outputPattern 输出时间的格式
* @return 返回字符串时间
*/
public static String formatTime(String inputTime, String inputPattern, String outputPattern)
{
Date date = parseTime0(inputTime, inputPattern);
//返回格式化后的字符串时间
return new SimpleDateFormat(outputPattern).format(date);
}

/**
* 将日期型时间转换为字符串
* @param date 日期型时间
* @param pattern 类型
* @return 返回字符串时间
*/
public static String formatTime(Date date, String pattern)
{
//返回格式化后的字符串时间
return new SimpleDateFormat(pattern).format(date);
}

/**
* 得到当前日期和时间
* @param pattern 格式类型
* @return 当前日期和时间
*/
public static String getJavaThisTime(String pattern)
{
return new SimpleDateFormat(pattern).format(new Date());
}

/**
* 获取今天开始时间的毫秒值
* @return 今天开始时间的毫秒值
*/
public static long getJavaTodayStartTime()
{
//获取JAVA系统当前时间
final Calendar calendar = Calendar.getInstance();

//使用内部方法获取今天的开始时间
return getCalendarDayTopTime(calendar, false).getTimeInMillis();
}

/**
* 获取今天结束时间的毫秒值
* @return 今天结束时间的毫秒值
*/
public static long getJavaTodayEndTime()
{
//获取JAVA系统当前时间
final Calendar calendar = Calendar.getInstance();

//使用内部方法获取今天的开始时间
return getCalendarDayTopTime(calendar, true).getTimeInMillis();
}

/**
* 获取今天开始时间的毫秒值
* @param calendar0 日历对象
* @param isEndDay 是否获取天的结束时间
* @return 返回日历对象一天的开始或结束时间
*/
public static Calendar getCalendarDayTopTime(Calendar calendar0, boolean isEndDay)
{
//检查日历对象
final Calendar calendar = null == calendar0 ? Calendar.getInstance(Locale.ENGLISH) : calendar0;

//清除当前的小时、分钟、秒 和 毫秒
calendar.set(Calendar.MILLISECOND, 0);//清除毫秒位数字
calendar.set(Calendar.SECOND, 0);//清除秒钟位数字
calendar.set(Calendar.MINUTE, 0);//清除分钟位数字
calendar.set(Calendar.HOUR_OF_DAY, 0);//清除小时位数字

//判断是否为结束时间
if (isEndDay)
{
//时间向后增加一天
calendar.add(Calendar.DATE, 1);
//退后一天的当天开始时间再减去一毫秒，则为当天的最后时间
calendar.add(Calendar.MILLISECOND, -1);
}

//返回日历对象
return calendar;
}

/**
* 得到昨天当前日期和时间
* @param pattern 格式类型
* @return 当前日期和时间
*/
public static String getJavaYesterdayThisTime(String pattern)
{
//获取系统当前时间
long thisTime = System.currentTimeMillis();

//获取昨天的当前时间
long yesterdayThisTime = addTime(thisTime, Calendar.DATE, -1);

//长整型时间转字符串
return formatTime(yesterdayThisTime, pattern);
}

/**
* 获取DB时间一天到数据库查询一次
* 时间格式为：yyyyMMddHHmmss
* @return 数据库系统时间
*/
public static String getGoodishDBTimeDaily()
{
//获取指定格式的数据库时间
return DAILY_GETTER.getFormatedGoodishDBThisTime(TimeKeys.YYYYMMDDHHMMSS);
}

/**
* 获取DB时间一天到数据库查询一次
* 时间格式为：yyyyMMddHHmmss
* @return 数据库系统时间
*/
public static long getGoodishDBTimeDailyInMillis()
{
//获取指定格式的数据库时间
return DAILY_GETTER.getGoodishDBThisTime();
}

/**
* 转换时间格式
* @param inputTime 时间参数
* @param toFormat 目标格式
* @return 目标格式的时间
*/
public static String switchTimeFormat(String inputTime, String toFormat)
{
//默认不支持特殊格式的时间格式进行检查跳转
return switchTimeFormat(inputTime, toFormat, false);
}

/**
* 转换时间格式
* @param inputTime 时间参数
* @param toFormat 目标格式
* @param specialPattern 特殊格式
* @return 目标格式的时间
*/
public static String switchTimeFormat(String inputTime, String toFormat, boolean specialPattern)
{
//判断时间是否为空，为空直接返回
if (StringUtils.isBlank(inputTime) || StringUtils.isBlank(toFormat))
{
return inputTime;
}

//根据输入时间获取格式
String fromFormat = getTimePattern(inputTime, toFormat, specialPattern);

//判断目标格式与当前格式是否一致,则直接返回
if (toFormat.equals(fromFormat))
{
return inputTime;
}

//进行时间格式转换
return switchTimeFormat(inputTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
}

/**
* 从一个时间格式转换到另一个时间格式
* @param dateTime 需要改变的时间
* @param fromFormat 原来的时间格式
* @param toFormat 目标时间格式
* @return 将原来的时间格式转换成需要的时间格式字符串
*/
public static String switchTimeFormat(String dateTime, String fromFormat, String toFormat)
{
//使用默认语言类型进行转换
return switchTimeFormat(dateTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
}

/**
* 从一个时间格式转换到另一个时间格式
* @param dateTime 需要改变的时间
* @param fromFormat 原来的时间格式
* @param fromLocale 语言类型
* @param toFormat 目标时间格式
* @param toLocale 语言类型
* @return 将原来的时间格式转换成需要的时间格式字符串
*/
public static String switchTimeFormat(String dateTime, String fromFormat,
Locale fromLocale, String toFormat, Locale toLocale)
{
//判断时间参数是否为空，为空直接返回
if (StringUtils.isBlank(dateTime))
{
return dateTime;
}

//源格式
final DateFormat from = new SimpleDateFormat(fromFormat, fromLocale);
//目的格式
final DateFormat to = new SimpleDateFormat(toFormat, toLocale);

try
{
final Date date = from.parse(dateTime);
return to.format(date);
}
catch (ParseException e)
{
return dateTime;
}
}

/**
* 检查字符串时间是为指定格式
* @param inputTime 字符串格式的时间
* @param pattern 类型
* @return 是否指定格式的时间
*/
public static boolean validateTimePattern(String inputTime, String pattern)
{
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);
//设置为强校验
dateFormat.setLenient(false);

try
{
//解析字符串时间
dateFormat.parse(inputTime);
}
catch (ParseException e)
{
return false;
}

//返回成功
return true;
}

/**
* 检查字符串时间是为指定格式
* @param inputTime 字符串格式的时间
* @param pattern 类型
* @return 是否指定格式的时间
*/
public static boolean validateForceTimePattern(String inputTime, String pattern)
{
//判断时间内容是否为空
if (StringUtils.isBlank(inputTime) || null == pattern)
{
return false;
}

//判断字符串长度是否一致
if (inputTime.length() != pattern.length())
{
return false;
}

//格式校验
return validateTimePattern(inputTime, pattern);
}

/**
* UTC日期对象与Local日历对象进行跳转
* @param calendar 日历对象
* @param localToUTC 是否本地转UTC
* @return 新的日历对象
*/
private static Calendar switchUTCAndLocal(Calendar calendar, boolean localToUTC)
{
//获取时区域
int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
int destOffset = calendar.get(Calendar.DST_OFFSET);

//获取偏移量值(小时值)
int hourOffset = (int)((zoneOffset + destOffset) / TimeKeys.HOUR_MILLIS);

//获取现有的小时数值
int curHours = calendar.get(Calendar.HOUR_OF_DAY);

//获取系统新的小时值
int newCurHours = localToUTC ? curHours - hourOffset : curHours + hourOffset;

//更改时间为标准时间
calendar.set(Calendar.HOUR_OF_DAY, newCurHours);

//返回当前日历对象
return calendar;
}

/**
* 转换UTC至本地日历
* @param utcCalendar UTC日历对象
* @return 本地日历对象
*/
public static Calendar changeUTCToLocal(Calendar utcCalendar)
{
return null == utcCalendar ? null : switchUTCAndLocal(utcCalendar, false);
}

/**
* 转换本地至UTC日历
* @param localCalendar 本地 日历对象
* @return UTC日历对象
*/
public static Calendar changeLocalToUTC(Calendar localCalendar)
{
return null == localCalendar ? null : switchUTCAndLocal(localCalendar, true);
}

/**
* 获取系统当前UTC日历对象
* @return 系统当前UTC日历对象
*/
public static Calendar getThisUTCCalendar()
{
//获取本地系统日历对象
Calendar calendar = Calendar.getInstance();

//日历对象转换为UTC
return switchUTCAndLocal(calendar, true);
}

/**
* 获取格式为yyyy-MM-dd HH:mm:ssUTC当前时间
* @return UTC当前时间
*/
public static String getUTCThisTime()
{
return getUTCThisTime(TimeKeys.YYYY_MM_DD_HH_MM_SS);
}

/**
* 获取系统当前时间
* @param pattern 指定格式
* @return 系统当前时间
*/
public static String getUTCThisTime(String pattern)
{
//日历对象转换为UTC
Calendar calendarUTC = getThisUTCCalendar();

//日历信息转字符串
return formatTime(calendarUTC.getTime(), pattern);
}

/**
* 将格林威治时间转化成本地时间,返回格式为String
* 格林威治时间+8小时=北京时间
* @param utcTime 传入的格林威治
* @param pattern 输入输出时间格式
* @return 本地时间
*/
public static String changeUTCToLocalString(String utcTime, String pattern)
{
return changeUTCToLocalString(utcTime, pattern, pattern);
}

/**
* 将格林威治时间转化成本地时间,返回格式为String
* 格林威治时间+8小时=北京时间
* @param utcTime 传入的格林威治
* @param inputPattern 输入时间格式
* @param outputPattern 输出时间格式
* @return 本地时间
*/
public static String changeUTCToLocalString(String utcTime, String inputPattern, String outputPattern)
{
//判断输入的UTC字符串是否为空
if (StringUtils.isBlank(utcTime))
{
return null;
}

//日期显示格式
SimpleDateFormat format = new SimpleDateFormat(inputPattern);
Date utcDate = format.parse(utcTime, new ParsePosition(utcTime.indexOf("")));

//获取日历对象
Calendar utcCalendar = Calendar.getInstance();
utcCalendar.setTime(utcDate);

//获取本地日历对象
Calendar localCalendar = switchUTCAndLocal(utcCalendar, false);

//转换时间为指定格式
return new SimpleDateFormat(outputPattern).format(localCalendar.getTime());
}

/**
* 将本地时间转化为UTC（格林威治）时间,返回格式为Calendar
* 格林时间+8小时=北京时间
* 说明：该方法不能自行删除，soap接口测试页面再使用
* @param localTime 传入的本地时间
* @param pattern 格式类型 时间 格式yyyy-MM-dd HH:mm:ss
* @return UTC（格林威治）时间
*/
public static Calendar changeToUTCCalendar(String localTime, String pattern)
{
//判断输入的UTC字符串是否为空
if (StringUtils.isBlank(localTime))
{
return null;
}

//获取系统当前日历对象
Calendar localCalendar = Calendar.getInstance();
// 日期显示格式
SimpleDateFormat format = new SimpleDateFormat(pattern);
Date localDate = format.parse(localTime, new ParsePosition(localTime.indexOf("")));
//把时间放到日历表中
localCalendar.setTime(localDate);

// 返回UTC时间格式
return switchUTCAndLocal(localCalendar, true);
}

/**
* 将本地时间转化为UTC（格林威治）时间
* 格林时间+8小时=北京时间
* @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
* @param pattern 输入输出时间格式
* @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
*/
public static String changeLocalToUTCString(String localTime, String pattern)
{
return changeLocalToUTCString(localTime, pattern, pattern);
}

/**
* 将本地时间转化为UTC（格林威治）时间
* 格林时间+8小时=北京时间
* @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
* @param inputPattern 输入时间格式
* @param outputPattern 输出时间格式
* @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
*/
public static String changeLocalToUTCString(String localTime, String inputPattern, String outputPattern)
{
Calendar calendar = changeToUTCCalendar(localTime, inputPattern);

//返回UTC时间格式
return new SimpleDateFormat(outputPattern).format(calendar.getTime());
}

/**
* 将Long型时间转换为字符串
* @param inputTime long型时间
* @param pattern 类型
* @return 返回字符串时间
*/
public static String parseTimeToStr(final long inputTime, final String pattern)
{
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);

//获取时间对象
final Date date = new Date(inputTime);

//返回格式化后的字符串时间
return dateFormat.format(date);
}

/**
* 解析事件内部方法
* @param inputTime 输入时间
* @param pattern 格式信息
* @return 返回码对象
*/
private static Date parseTime0(String inputTime, String pattern)
{
//判断输入时间是否为空
if (StringUtils.isBlank(inputTime))
{
return null;
}

//初始化指定格式的初始工具
DateFormat dateFormat = new SimpleDateFormat(pattern);
try
{
return dateFormat.parse(inputTime);
}
catch (Exception e)
{
return null;
}
}

/**
* 事件比较方法
* @param leftTime 左时间
* @param rightTime 右事件
* @param pattern 时间格式
* @return 整型 -1：（leftTime < rightTime）,0:相等； 1：（leftTime > rightTime）
*/
public static int compareTime(String leftTime, String rightTime, String pattern)
{
//格式化字符串
Date leftDate = parseTime0(leftTime, pattern);
Date rightDate = parseTime0(rightTime, pattern);

//判断时间对象是否为空
if (null == leftDate || null == rightDate)
{
return null == leftDate ? ((null == rightDate) ? 0 : -1) : 1;
}

//使用时间比较方法
return leftDate.compareTo(rightDate);
}

/**
* 获取本月第一天
* @param pattern 时间格式
* @return 当月第一天
*/
public static String getFirstDayThisMonth(String pattern)
{
//若格式为空时，赋默认值
if (StringUtils.isBlank(pattern))
{
pattern = TimeKeys.YYYY_MM_DD;
}
Calendar calendar = Calendar.getInstance();

//设置当前日期
calendar.setTime(new Date());

//取得当前月的最小日期(天)
int firstDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, firstDay);

//格式化成字符串
return new SimpleDateFormat(pattern).format(calendar.getTime());
}

/**
* 获取本月最后一天
* @param pattern 时间格式
* @return 本月最后一天
*/
public static String getLastDayThisMonth(String pattern)
{
//若格式为空时，赋默认值
if (StringUtils.isBlank(pattern))
{
pattern = TimeKeys.YYYY_MM_DD;
}
Calendar calendar = Calendar.getInstance();

//设置当前日期
calendar.setTime(new Date());

//取得当前月的最大日期(天)
int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, lastDay);

// 格式化成字符串
return new SimpleDateFormat(pattern).format(calendar.getTime());
}

/**
* 数据库时间协助类
* @version [COMMON, 2012-8-23]
*/
public static class DBTimeGetter
{
/**
* 访问的间隔时间
*/
private final long accessInterval;

/**
* 最近一次访问数据库时间
*/
private long lastAccessTime;

/**
* JAVA与数据库时间偏差
*/
private long offset;

/**
* <默认构造函数>
* @param accessInterval 访问的间隔时间
*/
public DBTimeGetter(long accessInterval)
{
this.accessInterval = accessInterval;
this.lastAccessTime = 0;
this.offset = 0;
}

/**
* 获取数据库时间
* @return 数据库时间
*/
public static long queryDBThisTime()
{
//定义数据库配置信息
String[] dbSystemParams;
//定义数据库当前时间对象
long dbThisTime = -1;

try
{
//访问数据库获取系统信息
dbSystemParams = SystemActions.queryDBSystemInfo();

//获取时间字符串字段信息
if (null != dbSystemParams && dbSystemParams.length > 0)
{
//解析时间至长整型
dbThisTime = parseTimeInMillis(dbSystemParams[0], TimeKeys.YYYY_MM_DD_HH_MM_SS);
}
}
catch (Exception e)
{
dbThisTime = -1;
}

//返回数据库当前时间
return dbThisTime;
}

/**
* 获取格式化后的数据库时间
* @param pattern 时间格式
* @return 格式化后的数据库时间
*/
public static String getFormatedDBThisTime(String pattern)
{
//获取数据库当前时间
long dbThisTime = queryDBThisTime();
if (dbThisTime < 0)
{
dbThisTime = System.currentTimeMillis();
}

//格式化时间
return formatTime(dbThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
}

/**
* 获取存在误差的数据库时间
* @return 数据库时间
*/
public long getGoodishDBThisTime()
{
//获取JAVA当前时间
long javaThisTime = System.currentTimeMillis();

//定义数据库当前时间
long dbThisTime;

//仅当间隔时间大于0，则进行误差时间获取
if (this.accessInterval <= 0)
{
dbThisTime = queryDBThisTime();
return dbThisTime < 0 ? javaThisTime : dbThisTime;
}

//判断当前时间是否满足更新条件
if (lastAccessTime + accessInterval <= javaThisTime)
{
//获取数据库时间
synchronized (this)
{
if (lastAccessTime + accessInterval <= javaThisTime)
{
this.lastAccessTime = javaThisTime;

//获取数据库时间
dbThisTime = queryDBThisTime();
if (dbThisTime < 0)
{
dbThisTime = javaThisTime;
}

//获取时间误差值
this.offset = dbThisTime - javaThisTime;
}
}
}

//获取数据库当前时间
return javaThisTime + this.offset;
}

/**
* 获取带误差数据库时间的格式化字符串
* @param pattern 格式字符串
* @return 格式化后的字符串
*/
public String getFormatedGoodishDBThisTime(String pattern)
{
//获取带误差的数据库时间
long goodishDBThisTime = getGoodishDBThisTime();

//格式化时间至字符串
return formatTime(goodishDBThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
}
}

/**
* 获取以毫秒的形式获取UTC当前时间
* @return 以毫秒的形式的UTC当前时间
*/
public static long getUTCTimeInMillis()
{
//1、取得本地时间
Calendar calendar = Calendar.getInstance();

//2、取得时间偏移量
int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);

//3、取得夏令时差
int dstOffset = calendar.get(Calendar.DST_OFFSET);

//4、从本地时间里扣除这些差量，即可以取得UTC时间
calendar.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));

return calendar.getTimeInMillis();
}
}
=====================================================================================================
public final class TimeKeys
{
//**************************************************************************************/
/**
* 一秒钟大小
*/
public static final long SECOND_MILLIS = 1000;

/**
* 一分钟大小
*/
public static final long MINUTE_MILLIS = 60 * SECOND_MILLIS;

/**
* 一小时大小
*/
public static final long HOUR_MILLIS = 60 * MINUTE_MILLIS;

/**
* 一天大小
*/
public static final long DAY_MILLIS = 24 * HOUR_MILLIS;

/**
* 半小时大小
*/
public static final long HALF_HOUR_MILLIS = 30 * MINUTE_MILLIS;

//**************************************************************************************/

//**************************************************************************************/
/**
* 时间格式1：yyyy-MM-dd HH:mm:ss.SSS
*/
public static final String YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";

/**
* 时间格式2： yyyy-MM-dd HH:mm:ss
*/
public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

/**
* 时间格式3： yyyyMMddHHmmss
*/
public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

/**
* 时间格式4： yyyy-MM-dd
*/
public static final String YYYY_MM_DD = "yyyy-MM-dd";

/**
* 时间格式5： yyyyMMdd
*/
public static final String YYYYMMDD = "yyyyMMdd";

/**
* 时间格式6： HH:mm:ss
*/
public static final String HH_MM_SS = "HH:mm:ss";

/**
* 时间格式7：MMddHHmm
*/
public static final String MMDDHHMM = "MMddHHmm";

/**
* 时间格式8： HHmmss
*/
public static final String HHMMSS = "HHmmss";

/**
* 时间格式：HHmmssSSS
*/
public static final String HHMMSSSSS = "HHmmssSSS";

/**
* 时间格式9：yyMMddHHmmssSSS
*/
public static final String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";

/**
* 全时间格式10： yyyy-MM-dd HH:mm:ss.SSS a Z E D w
*/
public static final String YYYY_MM_DD_HH_MM_SS_FULL = "yyyy-MM-dd HH:mm:ss.SSS a Z E D w";

/**
* 时间格式11： yyyy.MM.dd
*/
public static final String YYYY_MM_DD_EX1 = "yyyy.MM.dd";

/**
* JSON时间格式
*/
public static final String YYYY_MM_DD_T_HH_MM_SS = "yyyy-MM-dd'T'HH:mm:ss";

/**
* 年份
*/
public static final String YYYY = "yyyy";

/**
* 月份
*/
public static final String MM = "MM";

/**
* 日
*/
public static final String DD = "dd";

/**
* 小时
*/
public static final String HH = "HH";

/**
* 分钟
*/
public static final String MM_S = "mm";

/**
* 秒钟
*/
public static final String SS = "ss";

/**
* 年周
*/
public static final String YYYYW = "yyyyw";

/**
* 年周
*/
public static final String YYYY_W = "yyyy w";
//**************************************************************************************/

//**************************************************************************************/
/**
* 日期时间
*/
public static final String REGEX_YYYY_MM_DD = "\\d{4}-\\d{1,2}-\\d{1,2}";

/**
* 日期时间
*/
public static final String REGEX_YYYY_MM_DD_HH_MM_SS =
"\\d{4}-\\d{1,2}-\\d{1,2} ([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";

/**
* 日期时间
*/
public static final String REGEX_YYYYMMDD = "\\d{4}\\d{1,2}\\d{1,2}";

/**
* 日期时间
*/
public static final String REGEX_YYYYMMDDHHMMSS = "\\d{4}\\d{1,2}\\d{1,2}([01][0-9]|2[0-3])[0-5][0-9][0-5][0-9]";

/**
* 时间格式
*/
public static final String REGEX_HH_MM_SS = "([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";

/**
* 时间格式
*/
public static final String REGEX_YYYY_MM_DD_EX1 = "\\d{4}\\.\\d{1,2}\\.\\d{1,2}";

/**
* 常理类，私有化构造方法
*/
private TimeKeys()
{

}
}
======================================================================================
public final class StringUtils
{
/**
* 空字符串
*/
public static final String EMPTY = "";

/**
* 私有构造方法
*/
private StringUtils()
{
super();
}

/**
* 是否为空串(判断是否为null 或 "")
* isEmpty(null) = true;
* isEmpty("") = true;
* isEmpty(" ") = false;
* @param value 输入的字符串
* @return 是否为空串
*/
public static boolean isEmpty(String value)
{
return null == value || 0 == value.length();
}

/**
* 是否为空格串(判断是否为null 、"" 或 " ")
* isBlank(null) = true;
* isBlank("") = true;
* isBlank(" ") = true;
* @param value 输入的字符串
* @return 是否为空格串
*/
public static boolean isBlank(String value)
{
//是否为空串，如果为空串直接返回
return null == value || 0 == value.length() || EMPTY.equals(value.trim());
}

/**
* 字符串是否为非空
* @param value 输入的字符串
* @return 是否为非空格串
*/
public static boolean isNoBlank(String value)
{
return !isBlank(value);
}

/**
* trim字符串操作（如果字符串为空，则返回传入的默认值）
* @param value 需要处理的字符串
* @param defValue 默认值字符串
* @return 处理后的字符串
*/
public static String defaultIfBlank(String value, String defValue)
{
//是否为空格字符串
if (isBlank(value))
{
return defValue;
}

//将结果进行trim操作
return value.trim();
}

/**
* 字符串为空则使用默认字符串
* @param value 需要处理的字符串
* @param defValue 默认值字符串
* @return 处理后的字符串
*/
public static String defaultIfNull(String value, String defValue)
{
//是否为空格字符串
return null == value ? defValue : value.trim();
}

/**
* 字符串清理
* @param value 需要处理的字符串
* @return 清理后的字符串
*/
public static String emptyIfBlank(String value)
{
return null == value ? EMPTY : value.trim();
}

/**
* 正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否不匹配
*/
public static boolean noMatches(String value, String regex)
{
return !matches(value, regex);
}

/**
* 正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否匹配
*/
public static boolean matches(String value, String regex)
{
//如果校验字符为空
if ((null == value) || (null == regex))
{
return false;
}

//非空的话进行匹配
return value.matches(regex);
}

/**
* 先对输入字符串进行trim操作再进行正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否匹配
*/
public static boolean trimAndmatches(String value, String regex)
{
//如果校验字符为空
if ((null == value) || (null == regex))
{
return false;
}

//非空的话进行匹配
return value.trim().matches(regex);
}

/**
* 字符串trim并转小写
* @param value 待处理的字符串
* @return 转小写后字符串
*/
public static String trimAndLowerCase(String value)
{
return emptyIfBlank(value).toLowerCase(Locale.getDefault());
}

/**
* 字符串trim并转大写
* @param value 待处理的字符串
* @return 转大写后字符串
*/
public static String trimAndUpperCase(String value)
{
return emptyIfBlank(value).toUpperCase(Locale.getDefault());
}

/**
* ToString方法
* @param object 对象
* @return 描述信息
*/
public static String trimAndToString(Object object)
{
return null == object ? EMPTY : object.toString().trim();
}

/**
* 构建固定长度的字符串
* @param input 输入字符串
* @param length 长度
* @param filledChar 前补充字符
* @param fillHead 是头填充还是尾填充
* @return 固定长度后的字符串
*/
public static String buildFixedLength(String input, int length, char filledChar, boolean fillHead)
{
//获取格式化后的字符串
String inputTrimed = emptyIfBlank(input);

//判断字符串位数与固定长度数目关系，如果字符串位数大于要求固定长度，则直接返回
if (inputTrimed.length() >= length)
{
return inputTrimed;
}

//获取需要拼接的字节数组信息
int filledLength = length - inputTrimed.length();
char[] chars = new char[filledLength];
//使用待填充字符对填充字符数组进行填充
for (int i = 0; i < filledLength; i++)
{
chars[i] = filledChar;
}

//根据头填充还是尾填充返回结果
return fillHead ? new String(chars) + inputTrimed : inputTrimed + new String(chars);
}

/**
* 构建固定长度的字符串
* @param sequenceValue 序列值
* @param pattern 字符串格式
* @return 固定长度的序列字符串
*/
public static String buildFixedLength(long sequenceValue, String pattern)
{
//获取格式化的格式字符串信息
String newPattern = StringUtils.emptyIfBlank(pattern);

//使用字符串格式化进行格式化
DecimalFormat decimalFormat = new DecimalFormat(newPattern);

//返回格式化字符串
return decimalFormat.format(sequenceValue);
}

/**
* 判断是否为中文字符
* @param charValue 字符值
* @return 是否为中文字符
*/
public static boolean isChineseChar(char charValue)
{
//获取字符对象
Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(charValue);

//返回中文字符
return unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| unicodeBlock == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| unicodeBlock == Character.UnicodeBlock.GENERAL_PUNCTUATION
|| unicodeBlock == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| unicodeBlock == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS;
}

/**
* 获取字符串的字节长度
* @param value 字符串
* @return 字符串的字节长度：一个汉字的字节长度为2
*/
public static int getStringByteLength(String value)
{
//判断取值是否为空
return null == value ? 0 : value.getBytes().length;
}

/**
* 字符串剔除特殊字符
* @param input 输入字符串
* @param rejectChar 剔除字符
* @return 剔除后的字符串
*/
public static String rejectHeadSpecialChar(String input, char rejectChar)
{
//判断输入字符串是否为空，为空则直接返回空
if (StringUtils.isBlank(input))
{
return StringUtils.EMPTY;
}

//获取前后trim的字符串
String inputTrim = input.trim();

//获取输入字符串长度信息
int inputTrimLength = inputTrim.length();

//初始化特殊字符串标记位
int index = 0;

//循环检查字符
for (; index < inputTrimLength; index++)
{
//判断是否不等于特殊字符串，如果是则推出
if (rejectChar != inputTrim.charAt(index))
{
break;
}
}

//截取配置固定长度信息
return inputTrim.substring(index, inputTrimLength);
}
}