/** 标签开始 */
public int doStartTag() throws JspException {
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
UserInfoVo userInfo = WebUtils.getSessionContainer(request).getUserInfo();
String contextPath = request.getContextPath();
request.setAttribute("webContext", contextPath);
Dto dto = new BaseDto();
PropertiesHelper pHelper = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
dto.put("title", WebUtils.getParamValue("SYS_TITLE", request));
dto.put("contextPath", contextPath);
String titleIcon = WebUtils.getParamValue("TITLE_ICON", request);
dto.put("titleIcon", G4Utils.isEmpty(titleIcon) ? "G4Studio.ico" : titleIcon);
Dto themeDto = new BaseDto();
Dto resultDto = new BaseDto();
if (G4Utils.isNotEmpty(userInfo)) {
themeDto.put("userid", userInfo.getUserid());
resultDto = armTagSupportService.getEauserSubInfo(themeDto);
}
String theme = null;
if (G4Utils.isNotEmpty(resultDto)) theme = resultDto.getAsString("theme");
String defaultTheme = WebUtils.getParamValue("SYS_DEFAULT_THEME", request);
theme = G4Utils.isEmpty(theme) ? defaultTheme : theme;
dto.put("theme", theme);
String layout = null;
if (G4Utils.isNotEmpty(resultDto)) layout = resultDto.getAsString("layout");
String defaultLayout = WebUtils.getParamValue("APP_LAYOUT", request);
layout = G4Utils.isEmpty(layout) ? defaultLayout : layout;
dto.put("layout", layout);
String background = null;
if (G4Utils.isNotEmpty(resultDto)) background = resultDto.getAsString("background");
String defaultBackfround = WebUtils.getParamValue("DESKTOP_BACKGROUND", request);
background = G4Utils.isEmpty(background) ? defaultBackfround : background;
dto.put("background", background);
PropertiesHelper p = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
dto.put("extMode", p.getValue("extMode", TagConstant.Ext_Mode_Run));
dto.put("runMode", p.getValue("runMode", TagConstant.RUN_MODE_NORMAL));
dto.put("ajaxErrCode", G4Constants.Ajax_Timeout);
String micolor = pHelper.getValue("micolor", "blue");
dto.put("username", WebUtils.getSessionContainer(request).getUserInfo().getUsername());
dto.put("account", WebUtils.getSessionContainer(request).getUserInfo().getAccount());
Dto qDto = new BaseDto();
qDto.put("deptid", WebUtils.getSessionContainer(request).getUserInfo().getDeptid());
dto.put("deptname", armTagSupportService.getDepartmentInfo(qDto).getAsString("deptname"));
dto.put("userInfo", userInfo);
List menuList = getMenuList();
dto.put("menuList", menuList);
dto.put("paramList", WebUtils.getParamList(request));
TemplateEngine engine = TemplateEngineFactory.getTemplateEngine(TemplateType.VELOCITY);
DefaultTemplate template = new FileTemplate();
template.setTemplateResource(TagHelper.getTemplatePath(getClass().getName()));
StringWriter writer = engine.mergeTemplate(template, dto);
try {
pageContext.getOut().write(writer.toString());
} catch (IOException e) {
log.error(G4Constants.Exception_Head + e.getMessage());
e.printStackTrace();
}
return super.SKIP_BODY;
}
/**
* 初始化ApplicationContext对象
*
* @throws Exception
*/
private static void initApplicationContext() throws Exception {
PropertiesHelper pHelper = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
String forceLoad = pHelper.getValue("forceLoad", SystemConstants.FORCELOAD_N);
try {
if (forceLoad.equalsIgnoreCase(SystemConstants.FORCELOAD_N)) {
log.info("系统正在初始化服务容器...");
}
applicationContext =
new ClassPathXmlApplicationContext(new String[] {"config\\global.config.xml"});
if (forceLoad.equalsIgnoreCase(SystemConstants.FORCELOAD_N)) {
log.info("容器初始化成功啦，您的托管Bean已经被实例化。");
}
} catch (Exception e) {
log.error("服务容器初始化失败.");
log.error(G4Constants.Exception_Head + "初始化服务容器发生错误,请仔细检查您的配置文件喔!\n" + e.getMessage());
e.printStackTrace();
System.exit(0);
throw e;
}
}
/**
* 常见的辅助类
*
* @author XiongChun
* @since 2009-07-15
*/
public class G4Utils {
private static Log log = LogFactory.getLog(G4Utils.class);
/** DES算法密钥 */
private static final byte[] DES_KEY = {21, 1, -110, 82, -32, -85, -128, -65};
private static String HanDigiStr[] =
new String[] {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
private static String HanDiviStr[] =
new String[] {
"", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾",
"佰", "仟", "万", "拾", "佰", "仟"
};
private static PropertiesHelper pHelper =
PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
/**
* 判断对象是否Empty(null或元素为0)<br>
* 实用于对如下对象做判断:String Collection及其子类 Map及其子类
*
* @param pObj 待检查对象
* @return boolean 返回的布尔值
*/
public static boolean isEmpty(Object pObj) {
if (pObj == null) return true;
if (pObj == "") return true;
if (pObj instanceof String) {
if (((String) pObj).length() == 0) {
return true;
}
} else if (pObj instanceof Collection) {
if (((Collection) pObj).size() == 0) {
return true;
}
} else if (pObj instanceof Map) {
if (((Map) pObj).size() == 0) {
return true;
}
}
return false;
}
/**
* 判断对象是否为NotEmpty(!null或元素>0)<br>
* 实用于对如下对象做判断:String Collection及其子类 Map及其子类
*
* @param pObj 待检查对象
* @return boolean 返回的布尔值
*/
public static boolean isNotEmpty(Object pObj) {
if (pObj == null) return false;
if (pObj == "") return false;
if (pObj instanceof String) {
if (((String) pObj).length() == 0) {
return false;
}
} else if (pObj instanceof Collection) {
if (((Collection) pObj).size() == 0) {
return false;
}
} else if (pObj instanceof Map) {
if (((Map) pObj).size() == 0) {
return false;
}
}
return true;
}
/**
* 判断一个字符串是否由数字、字母、数字字母组成
*
* @param pStr 需要判断的字符串
* @param pStyle 判断规则
* @return boolean 返回的布尔值
*/
public static boolean isTheStyle(String pStr, String pStyle) {
for (int i = 0; i < pStr.length(); i++) {
char c = pStr.charAt(i);
if (pStyle.equals(G4Constants.S_STYLE_N)) {
if (!Character.isDigit(c)) return false;
} else if (pStyle.equals(G4Constants.S_STYLE_L)) {
if (!Character.isLetter(c)) return false;
} else if (pStyle.equals(G4Constants.S_STYLE_NL)) {
if (Character.isLetterOrDigit(c)) return false;
}
}
return true;
}
/**
* JavaBean之间对象属性值拷贝
*
* @param pFromObj Bean源对象
* @param pToObj Bean目标对象
*/
public static void copyPropBetweenBeans(Object pFromObj, Object pToObj) {
if (pToObj != null) {
try {
BeanUtils.copyProperties(pToObj, pFromObj);
} catch (Exception e) {
log.error("==开发人员请注意:==\n JavaBean之间的属性值拷贝发生错误啦!" + "\n详细错误信息如下:");
e.printStackTrace();
}
}
}
/**
* 将JavaBean对象中的属性值拷贝到Dto对象
*
* @param pFromObj JavaBean对象源
* @param pToDto Dto目标对象
*/
public static void copyPropFromBean2Dto(Object pFromObj, Dto pToDto) {
if (pToDto != null) {
try {
pToDto.putAll(BeanUtils.describe(pFromObj));
// BeanUtils自动加入了一个Key为class的键值,故将其移除
pToDto.remove("class");
} catch (Exception e) {
log.error("==开发人员请注意:==\n 将JavaBean属性值拷贝到Dto对象发生错误啦!" + "\n详细错误信息如下:");
e.printStackTrace();
}
}
}
/**
* 将传入的身份证号码进行校验，并返回一个对应的18位身份证
*
* @param personIDCode 身份证号码
* @return String 十八位身份证号码
* @throws 无效的身份证号
*/
public static String getFixedPersonIDCode(String personIDCode) throws Exception {
if (personIDCode == null) throw new Exception("输入的身份证号无效，请检查");
if (personIDCode.length() == 18) {
if (isIdentity(personIDCode)) return personIDCode;
else throw new Exception("输入的身份证号无效，请检查");
} else if (personIDCode.length() == 15) return fixPersonIDCodeWithCheck(personIDCode);
else throw new Exception("输入的身份证号无效，请检查");
}
/**
* 修补15位居民身份证号码为18位，并校验15位身份证有效性
*
* @param personIDCode 十五位身份证号码
* @return String 十八位身份证号码
* @throws 无效的身份证号
*/
public static String fixPersonIDCodeWithCheck(String personIDCode) throws Exception {
if (personIDCode == null || personIDCode.trim().length() != 15)
throw new Exception("输入的身份证号不足15位，请检查");
if (!isIdentity(personIDCode)) throw new Exception("输入的身份证号无效，请检查");
return fixPersonIDCodeWithoutCheck(personIDCode);
}
/**
* 修补15位居民身份证号码为18位，不校验身份证有效性
*
* @param personIDCode 十五位身份证号码
* @return 十八位身份证号码
* @throws 身份证号参数不是15位
*/
public static String fixPersonIDCodeWithoutCheck(String personIDCode) throws Exception {
if (personIDCode == null || personIDCode.trim().length() != 15)
throw new Exception("输入的身份证号不足15位，请检查");
String id17 =
personIDCode.substring(0, 6) + "19" + personIDCode.substring(6, 15); // 15位身份证补'19'
char[] code = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'}; // 11个校验码字符
int[] factor = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1}; // 18个加权因子
int[] idcd = new int[18];
int sum; // 根据公式 ∑(ai×Wi) 计算
int remainder; // 第18位校验码
for (int i = 0; i < 17; i++) {
idcd[i] = Integer.parseInt(id17.substring(i, i + 1));
}
sum = 0;
for (int i = 0; i < 17; i++) {
sum = sum + idcd[i] * factor[i];
}
remainder = sum % 11;
String lastCheckBit = String.valueOf(code[remainder]);
return id17 + lastCheckBit;
}
/**
* 判断是否是有效的18位或15位居民身份证号码
*
* @param identity 18位或15位居民身份证号码
* @return 是否为有效的身份证号码
*/
public static boolean isIdentity(String identity) {
if (identity == null) return false;
if (identity.length() == 18 || identity.length() == 15) {
String id15 = null;
if (identity.length() == 18) id15 = identity.substring(0, 6) + identity.substring(8, 17);
else id15 = identity;
try {
Long.parseLong(id15); // 校验是否为数字字符串
String birthday = "19" + id15.substring(6, 12);
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
sdf.parse(birthday); // 校验出生日期
if (identity.length() == 18 && !fixPersonIDCodeWithoutCheck(id15).equals(identity))
return false; // 校验18位身份证
} catch (Exception e) {
return false;
}
return true;
} else return false;
}
/**
* 从身份证号中获取出生日期，身份证号可以为15位或18位
*
* @param identity 身份证号
* @return 出生日期
* @throws 身份证号出生日期段有误
*/
public static Timestamp getBirthdayFromPersonIDCode(String identity) throws Exception {
String id = getFixedPersonIDCode(identity);
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
try {
Timestamp birthday = new Timestamp(sdf.parse(id.substring(6, 14)).getTime());
return birthday;
} catch (ParseException e) {
throw new Exception("不是有效的身份证号，请检查");
}
}
/**
* 从身份证号获取性别
*
* @param identity 身份证号
* @return 性别代码
* @throws Exception 无效的身份证号码
*/
public static String getGenderFromPersonIDCode(String identity) throws Exception {
String id = getFixedPersonIDCode(identity);
char sex = id.charAt(16);
return sex % 2 == 0 ? "2" : "1";
}
/**
* 将货币转换为大写形式(类内部调用)
*
* @param val
* @return String
*/
private static String PositiveIntegerToHanStr(String NumStr) {
// 输入字符串必须正整数，只允许前导空格(必须右对齐)，不宜有前导零
String RMBStr = "";
boolean lastzero = false;
boolean hasvalue = false; // 亿、万进位前有数值标记
int len, n;
len = NumStr.length();
if (len > 15) return "数值过大!";
for (int i = len - 1; i >= 0; i--) {
if (NumStr.charAt(len - i - 1) == ' ') continue;
n = NumStr.charAt(len - i - 1) - '0';
if (n < 0 || n > 9) return "输入含非数字字符!";
if (n != 0) {
if (lastzero) RMBStr += HanDigiStr[0]; // 若干零后若跟非零值，只显示一个零
// 除了亿万前的零不带到后面
// if( !( n==1 && (i%4)==1 && (lastzero || i==len-1) ) )
// 如十进位前有零也不发壹音用此行
if (!(n == 1 && (i % 4) == 1 && i == len - 1)) // 十进位处于第一位不发壹音
RMBStr += HanDigiStr[n];
RMBStr += HanDiviStr[i]; // 非零值后加进位，个位为空
hasvalue = true; // 置万进位前有值标记
} else {
if ((i % 8) == 0 || ((i % 8) == 4 && hasvalue)) // 亿万之间必须有非零值方显示万
RMBStr += HanDiviStr[i]; // “亿”或“万”
}
if (i % 8 == 0) hasvalue = false; // 万进位前有值标记逢亿复位
lastzero = (n == 0) && (i % 4 != 0);
}
if (RMBStr.length() == 0) return HanDigiStr[0]; // 输入空字符或"0"，返回"零"
return RMBStr;
}
/**
* 将货币转换为大写形式
*
* @param val 传入的数据
* @return String 返回的人民币大写形式字符串
*/
public static String numToRMBStr(double val) {
String SignStr = "";
String TailStr = "";
long fraction, integer;
int jiao, fen;
if (val < 0) {
val = -val;
SignStr = "负";
}
if (val > 99999999999999.999 || val < -99999999999999.999) return "数值位数过大!";
// 四舍五入到分
long temp = Math.round(val * 100);
integer = temp / 100;
fraction = temp % 100;
jiao = (int) fraction / 10;
fen = (int) fraction % 10;
if (jiao == 0 && fen == 0) {
TailStr = "整";
} else {
TailStr = HanDigiStr[jiao];
if (jiao != 0) TailStr += "角";
// 零元后不写零几分
if (integer == 0 && jiao == 0) TailStr = "";
if (fen != 0) TailStr += HanDigiStr[fen] + "分";
}
// 下一行可用于非正规金融场合，0.03只显示“叁分”而不是“零元叁分”
// if( !integer ) return SignStr+TailStr;
return SignStr + PositiveIntegerToHanStr(String.valueOf(integer)) + "元" + TailStr;
}
/**
* 获取指定年份和月份对应的天数
*
* @param year 指定的年份
* @param month 指定的月份
* @return int 返回天数
*/
public static int getDaysInMonth(int year, int month) {
if ((month == 1)
|| (month == 3)
|| (month == 5)
|| (month == 7)
|| (month == 8)
|| (month == 10)
|| (month == 12)) {
return 31;
} else if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
return 30;
} else {
if (((year % 4) == 0) && ((year % 100) != 0) || ((year % 400) == 0)) {
return 29;
} else {
return 28;
}
}
}
/**
* 根据所给的起止时间来计算间隔的天数
*
* @param startDate 起始时间
* @param endDate 结束时间
* @return int 返回间隔天数
*/
public static int getIntervalDays(java.sql.Date startDate, java.sql.Date endDate) {
long startdate = startDate.getTime();
long enddate = endDate.getTime();
long interval = enddate - startdate;
int intervalday = (int) (interval / (1000 * 60 * 60 * 24));
return intervalday;
}
/**
* 根据所给的起止时间来计算间隔的月数
*
* @param startDate 起始时间
* @param endDate 结束时间
* @return int 返回间隔月数
*/
public static int getIntervalMonths(java.sql.Date startDate, java.sql.Date endDate) {
Calendar startCal = Calendar.getInstance();
startCal.setTime(startDate);
Calendar endCal = Calendar.getInstance();
endCal.setTime(endDate);
int startDateM = startCal.MONTH;
int startDateY = startCal.YEAR;
int enddatem = endCal.MONTH;
int enddatey = endCal.YEAR;
int interval = (enddatey * 12 + enddatem) - (startDateY * 12 + startDateM);
return interval;
}
/**
* 返回当前日期时间字符串<br>
* 默认格式:yyyy-mm-dd hh:mm:ss
*
* @return String 返回当前字符串型日期时间
*/
public static String getCurrentTime() {
String returnStr = null;
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
returnStr = f.format(date);
return returnStr;
}
/**
* 返回当前日期时间字符串<br>
* 默认格式:yyyymmddhhmmss
*
* @return String 返回当前字符串型日期时间
*/
public static BigDecimal getCurrentTimeAsNumber() {
String returnStr = null;
SimpleDateFormat f = new SimpleDateFormat("yyyyMMddHHmmss");
Date date = new Date();
returnStr = f.format(date);
return new BigDecimal(returnStr);
}
/**
* 返回自定义格式的当前日期时间字符串
*
* @param format 格式规则
* @return String 返回当前字符串型日期时间
*/
public static String getCurrentTime(String format) {
String returnStr = null;
SimpleDateFormat f = new SimpleDateFormat(format);
Date date = new Date();
returnStr = f.format(date);
return returnStr;
}
/**
* 返回当前字符串型日期
*
* @return String 返回的字符串型日期
*/
public static String getCurDate() {
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpledateformat = new SimpleDateFormat("yyyy-MM-dd");
String strDate = simpledateformat.format(calendar.getTime());
return strDate;
}
/**
* 返回指定格式的字符型日期
*
* @param date
* @param formatString
* @return
*/
public static String Date2String(Date date, String formatString) {
if (G4Utils.isEmpty(date)) {
return null;
}
SimpleDateFormat simpledateformat = new SimpleDateFormat(formatString);
String strDate = simpledateformat.format(date);
return strDate;
}
/**
* 返回当前字符串型日期
*
* @param format 格式规则
* @return String 返回的字符串型日期
*/
public static String getCurDate(String format) {
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpledateformat = new SimpleDateFormat(format);
String strDate = simpledateformat.format(calendar.getTime());
return strDate;
}
/**
* 返回TimeStamp对象
*
* @return
*/
public static Timestamp getCurrentTimestamp() {
Object obj = TypeCaseHelper.convert(getCurrentTime(), "Timestamp", "yyyy-MM-dd HH:mm:ss");
if (obj != null) return (Timestamp) obj;
else return null;
}
/**
* 将字符串型日期转换为日期型
*
* @param strDate 字符串型日期
* @param srcDateFormat 源日期格式
* @param dstDateFormat 目标日期格式
* @return Date 返回的util.Date型日期
*/
public static Date stringToDate(String strDate, String srcDateFormat, String dstDateFormat) {
Date rtDate = null;
Date tmpDate = (new SimpleDateFormat(srcDateFormat)).parse(strDate, new ParsePosition(0));
String tmpString = null;
if (tmpDate != null) tmpString = (new SimpleDateFormat(dstDateFormat)).format(tmpDate);
if (tmpString != null)
rtDate = (new SimpleDateFormat(dstDateFormat)).parse(tmpString, new ParsePosition(0));
return rtDate;
}
/**
* 合并字符串数组
*
* @param a 字符串数组0
* @param b 字符串数组1
* @return 返回合并后的字符串数组
*/
public static String[] mergeStringArray(String[] a, String[] b) {
if (a.length == 0 || isEmpty(a)) return b;
if (b.length == 0 || isEmpty(b)) return a;
String[] c = new String[a.length + b.length];
for (int m = 0; m < a.length; m++) {
c[m] = a[m];
}
for (int i = 0; i < b.length; i++) {
c[a.length + i] = b[i];
}
return c;
}
/** 对文件流输出下载的中文文件名进行编码 屏蔽各种浏览器版本的差异性 */
public static String encodeChineseDownloadFileName(HttpServletRequest request, String pFileName) {
String agent = request.getHeader("USER-AGENT");
try {
if (null != agent && -1 != agent.indexOf("MSIE")) {
pFileName = URLEncoder.encode(pFileName, "utf-8");
} else {
pFileName = new String(pFileName.getBytes("utf-8"), "iso8859-1");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return pFileName;
}
/**
* 根据日期获取星期
*
* @param strdate
* @return
*/
public static String getWeekDayByDate(String strdate) {
final String dayNames[] = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
SimpleDateFormat sdfInput = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance();
Date date = new Date();
try {
date = sdfInput.parse(strdate);
} catch (ParseException e) {
e.printStackTrace();
}
calendar.setTime(date);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
if (dayOfWeek < 0) dayOfWeek = 0;
return dayNames[dayOfWeek];
}
/**
* 判断是否是IE浏览器
*
* @param userAgent
* @return
*/
public static boolean isIE(HttpServletRequest request) {
String userAgent = request.getHeader("USER-AGENT").toLowerCase();
boolean isIe = true;
int index = userAgent.indexOf("msie");
if (index == -1) {
isIe = false;
}
return isIe;
}
/**
* 判断是否是Chrome浏览器
*
* @param userAgent
* @return
*/
public static boolean isChrome(HttpServletRequest request) {
String userAgent = request.getHeader("USER-AGENT").toLowerCase();
boolean isChrome = true;
int index = userAgent.indexOf("chrome");
if (index == -1) {
isChrome = false;
}
return isChrome;
}
/**
* 判断是否是Firefox浏览器
*
* @param userAgent
* @return
*/
public static boolean isFirefox(HttpServletRequest request) {
String userAgent = request.getHeader("USER-AGENT").toLowerCase();
boolean isFirefox = true;
int index = userAgent.indexOf("firefox");
if (index == -1) {
isFirefox = false;
}
return isFirefox;
}
/**
* 获取客户端类型
*
* @param userAgent
* @return
*/
public static String getClientExplorerType(HttpServletRequest request) {
String userAgent = request.getHeader("USER-AGENT").toLowerCase();
String explorer = "非主流浏览器";
if (isIE(request)) {
int index = userAgent.indexOf("msie");
explorer = userAgent.substring(index, index + 8);
} else if (isChrome(request)) {
int index = userAgent.indexOf("chrome");
explorer = userAgent.substring(index, index + 12);
} else if (isFirefox(request)) {
int index = userAgent.indexOf("firefox");
explorer = userAgent.substring(index, index + 11);
}
return explorer.toUpperCase();
}
/**
* 基于MD5算法的单向加密
*
* @param strSrc 明文
* @return 返回密文
*/
public static String encryptBasedMd5(String strSrc) {
String outString = null;
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] outByte = md5.digest(strSrc.getBytes("UTF-8"));
outString = outByte.toString();
} catch (Exception e) {
e.printStackTrace();
}
return outString;
}
/**
* 数据加密，算法（DES）
*
* @param data 要进行加密的数据
* @return 加密后的数据
*/
public static String encryptBasedDes(String data) {
String encryptedData = null;
try {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
DESKeySpec deskey = new DESKeySpec(DES_KEY);
// 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey key = keyFactory.generateSecret(deskey);
// 加密对象
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, key, sr);
// 加密，并把字节数组编码成字符串
encryptedData = new BASE64Encoder().encode(cipher.doFinal(data.getBytes()));
} catch (Exception e) {
log.error("加密错误，错误信息：", e);
throw new RuntimeException("加密错误，错误信息：", e);
}
return encryptedData;
}
/**
* 数据解密，算法（DES）
*
* @param cryptData 加密数据
* @return 解密后的数据
*/
public static String decryptBasedDes(String cryptData) {
String decryptedData = null;
try {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
DESKeySpec deskey = new DESKeySpec(DES_KEY);
// 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey key = keyFactory.generateSecret(deskey);
// 解密对象
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, key, sr);
// 把字符串解码为字节数组，并解密
decryptedData =
new String(cipher.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(cryptData)));
} catch (Exception e) {
log.error("解密错误，错误信息：", e);
throw new RuntimeException("解密错误，错误信息：", e);
}
return decryptedData;
}
/**
* JS输出含有\n的特殊处理
*
* @param pStr
* @return
*/
public static String replace4JsOutput(String pStr) {
pStr = pStr.replace("\r\n", "<br/> ");
pStr = pStr.replace("\t", " ");
pStr = pStr.replace(" ", " ");
return pStr;
}
/**
* 获取class文件所在绝对路径
*
* @param cls
* @return
* @throws IOException
*/
public static String getPathFromClass(Class cls) {
String path = null;
if (cls == null) {
throw new NullPointerException();
}
URL url = getClassLocationURL(cls);
if (url != null) {
path = url.getPath();
if ("jar".equalsIgnoreCase(url.getProtocol())) {
try {
path = new URL(path).getPath();
} catch (MalformedURLException e) {
}
int location = path.indexOf("!/");
if (location != -1) {
path = path.substring(0, location);
}
}
File file = new File(path);
try {
path = file.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
}
}
return path;
}
/**
* 这个方法可以通过与某个类的class文件的相对路径来获取文件或目录的绝对路径。 通常在程序中很难定位某个相对路径，特别是在B/S应用中。
* 通过这个方法，我们可以根据我们程序自身的类文件的位置来定位某个相对路径。 比如：某个txt文件相对于程序的Test类文件的路径是../../resource/test.txt，
* 那么使用本方法Path.getFullPathRelateClass("../../resource/test.txt",Test.class) 得到的结果是txt文件的在系统中的绝对路径。
*
* @param relatedPath 相对路径
* @param cls 用来定位的类
* @return 相对路径所对应的绝对路径
* @throws IOException 因为本方法将查询文件系统，所以可能抛出IO异常
*/
public static String getFullPathRelateClass(String relatedPath, Class cls) {
String path = null;
if (relatedPath == null) {
throw new NullPointerException();
}
String clsPath = getPathFromClass(cls);
File clsFile = new File(clsPath);
String tempPath = clsFile.getParent() + File.separator + relatedPath;
File file = new File(tempPath);
try {
path = file.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
}
return path;
}
/**
* 获取类的class文件位置的URL
*
* @param cls
* @return
*/
private static URL getClassLocationURL(final Class cls) {
if (cls == null) throw new IllegalArgumentException("null input: cls");
URL result = null;
final String clsAsResource = cls.getName().replace('.', '/').concat(".class");
final ProtectionDomain pd = cls.getProtectionDomain();
if (pd != null) {
final CodeSource cs = pd.getCodeSource();
if (cs != null) result = cs.getLocation();
if (result != null) {
if ("file".equals(result.getProtocol())) {
try {
if (result.toExternalForm().endsWith(".jar")
|| result.toExternalForm().endsWith(".zip"))
result =
new URL(
"jar:".concat(result.toExternalForm()).concat("!/").concat(clsAsResource));
else if (new File(result.getFile()).isDirectory())
result = new URL(result, clsAsResource);
} catch (MalformedURLException ignore) {
}
}
}
}
if (result == null) {
final ClassLoader clsLoader = cls.getClassLoader();
result =
clsLoader != null
? clsLoader.getResource(clsAsResource)
: ClassLoader.getSystemResource(clsAsResource);
}
return result;
}
/**
* 获取start到end区间的随机数,不包含start+end
*
* @param start
* @param end
* @return
*/
public static BigDecimal getRandom(int start, int end) {
return new BigDecimal(start + Math.random() * end);
}
/**
* 将字符串写入指定文件 (当指定的父路径中文件夹不存在时，会最大限度去创建，以保证保存成功！)
*
* @param res 原字符串
* @param filePath 文件路径
* @return 成功标记
*/
public static boolean writeString2File(String res, String filePath) {
boolean flag = true;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
File distFile = new File(filePath);
if (!distFile.getParentFile().exists()) distFile.getParentFile().mkdirs();
bufferedReader = new BufferedReader(new StringReader(res));
bufferedWriter = new BufferedWriter(new FileWriter(distFile));
char buf[] = new char[1024];
int len;
while ((len = bufferedReader.read(buf)) != -1) {
bufferedWriter.write(buf, 0, len);
}
bufferedWriter.flush();
bufferedReader.close();
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
flag = false;
return flag;
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return flag;
}
/**
* 文本文件转换为指定编码的字符串
*
* @param file 文本文件
* @param encoding 编码类型
* @return 转换后的字符串
* @throws IOException
*/
public static String readStringFromFile(File file, String encoding) {
InputStreamReader reader = null;
StringWriter writer = new StringWriter();
try {
if (encoding == null || "".equals(encoding.trim())) {
reader = new InputStreamReader(new FileInputStream(file), encoding);
} else {
reader = new InputStreamReader(new FileInputStream(file));
}
char[] buffer = new char[1024];
int n = 0;
while (-1 != (n = reader.read(buffer))) {
writer.write(buffer, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if (reader != null)
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (writer != null) return writer.toString();
else return null;
}
/**
* 字符串编码转换工具类
*
* @param pString
* @return
*/
public static String getGBK(String pString) {
if (isEmpty(pString)) {
return "";
}
try {
pString = new String(pString.getBytes("ISO-8859-1"), "GBK");
} catch (UnsupportedEncodingException e) {
log.error(G4Constants.Exception_Head + "不支持的字符集编码");
e.printStackTrace();
}
return pString;
}
}
/** 标签开始 */
public int doStartTag() throws JspException {
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
UserInfoVo userInfo = WebUtils.getSessionContainer(request).getUserInfo();
String contextPath = request.getContextPath();
request.setAttribute("webContext", contextPath);
Dto dto = new BaseDto();
PropertiesHelper pHelper = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
String micolor = pHelper.getValue("micolor", "blue");
dto.put("micolor", micolor);
String urlSecurity = pHelper.getValue("urlSecurity", "1");
dto.put("urlSecurity", urlSecurity);
dto.put("urlSecurity2", urlSecurity2);
dto.put("userInfo", userInfo);
dto.put("ajaxErrCode", G4Constants.Ajax_Timeout);
dto.put("requestURL", request.getRequestURL());
dto.put("contextPath", contextPath);
dto.put("doctypeEnable", doctypeEnable);
dto.put("extDisabled", G4Utils.isEmpty(extDisabled) ? "false" : extDisabled);
dto.put("title", G4Utils.isEmpty(title) ? "G4Studio" : title);
dto.put("jqueryEnabled", G4Utils.isEmpty(jqueryEnabled) ? "false" : jqueryEnabled);
dto.put("showLoading", G4Utils.isEmpty(showLoading) ? "true" : showLoading);
dto.put("uxEnabled", uxEnabled);
dto.put("exportExceptionWindow", exportExceptionWindow);
dto.put("fcfEnabled", fcfEnabled);
dto.put("exportParams", exportParams);
dto.put("exportUserinfo", exportUserinfo);
dto.put("isSubPage", isSubPage);
dto.put("pageLoadMsg", WebUtils.getParamValue("PAGE_LOAD_MSG", request));
String titleIcon = WebUtils.getParamValue("TITLE_ICON", request);
dto.put("titleIcon", G4Utils.isEmpty(titleIcon) ? "G4Studio.ico" : titleIcon);
if (exportParams.equals("true")) {
dto.put("paramList", WebUtils.getParamList(request));
}
// String agent = request.getHeader("user-agent");
// dto.put("firefox", agent.indexOf("Firefox") == -1 ? "false" : "true");
PropertiesHelper p = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
dto.put("extMode", p.getValue("extMode", TagConstant.Ext_Mode_Run));
dto.put("runMode", p.getValue("runMode", TagConstant.RUN_MODE_NORMAL));
Dto themeDto = new BaseDto();
Dto resultDto = new BaseDto();
if (G4Utils.isNotEmpty(userInfo)) {
themeDto.put("userid", userInfo.getUserid());
resultDto = armTagSupportService.getEauserSubInfo(themeDto);
}
String theme = null;
if (G4Utils.isNotEmpty(resultDto)) theme = resultDto.getAsString("theme");
String defaultTheme = WebUtils.getParamValue("SYS_DEFAULT_THEME", request);
theme = G4Utils.isEmpty(theme) ? defaultTheme : theme;
dto.put("theme", theme);
TemplateEngine engine = TemplateEngineFactory.getTemplateEngine(TemplateType.VELOCITY);
DefaultTemplate template = new FileTemplate();
template.setTemplateResource(TagHelper.getTemplatePath(getClass().getName()));
StringWriter writer = engine.mergeTemplate(template, dto);
try {
pageContext.getOut().write(writer.toString());
} catch (IOException e) {
log.error(G4Constants.Exception_Head + e.getMessage());
e.printStackTrace();
}
return super.EVAL_BODY_INCLUDE;
}
/** 应用平台启动 */
private void systemStartup(ServletContext servletContext) {
PropertiesHelper pHelper = PropertiesFactory.getPropertiesHelper(PropertiesFile.G4);
String forceLoad = pHelper.getValue("forceLoad", SystemConstants.FORCELOAD_N);
long start = System.currentTimeMillis();
if (forceLoad.equalsIgnoreCase(SystemConstants.FORCELOAD_N)) {
log.info("*******************************************************");
log.info("G4系统集成与应用开发平台[G4Studio]开始启动...");
log.info("*******************************************************");
}
try {
wac = SpringBeanLoader.getApplicationContext();
} catch (Exception e) {
success = false;
e.printStackTrace();
}
if (success) {
MonitorService monitorService =
(MonitorService) SpringBeanLoader.getSpringBean("monitorService");
monitorService.deleteHttpSession(new BaseDto());
try {
initDbType();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (success) {
log.info("系统开始启动字典装载程序...");
log.info("开始加载字典...");
Reader g4Reader = (Reader) SpringBeanLoader.getSpringBean("g4Reader");
List codeList = null;
try {
codeList = g4Reader.queryForList("Resource.getCodeViewList");
log.info("字典加载成功!");
} catch (Exception e) {
success = false;
log.error("字典加载失败!");
e.printStackTrace();
}
servletContext.setAttribute("EACODELIST", codeList);
}
if (success) {
log.info("系统开始启动全局参数表装载程序...");
log.info("开始加载全局参数表...");
List paramList = null;
try {
Reader g4Reader = (Reader) SpringBeanLoader.getSpringBean("g4Reader");
paramList = g4Reader.queryForList("Resource.getParamList");
log.info("全局参数表加载成功!");
} catch (Exception e) {
success = false;
log.error("全局参数表加载失败!");
e.printStackTrace();
}
servletContext.setAttribute("EAPARAMLIST", paramList);
}
long timeSec = (System.currentTimeMillis() - start) / 1000;
log.info("********************************************");
if (success) {
log.info("G4系统集成与应用开发平台[G4Studio]启动成功[" + G4Utils.getCurrentTime() + "]");
log.info("启动总耗时: " + timeSec / 60 + "分 " + timeSec % 60 + "秒 ");
} else {
log.error("G4系统集成与应用开发平台[G4Studio]启动失败[" + G4Utils.getCurrentTime() + "]");
log.error("启动总耗时: " + timeSec / 60 + "分" + timeSec % 60 + "秒");
}
log.info("********************************************");
}
