import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 项目中常用的工具类
*
* @author tuozixuan
*
*/
public class CommonUtil
{
/**
* 是否为空，包括null和空格字符串
*
* @param text 文本
* @return boolean 是否为空
*/
public static boolean isEmpty(String text)
{
boolean result = false;
if (text == null || "".equals(text.trim()))
{
result = true;
}
return result;
}
/**
* 是否不为空，包括null和空格字符串
*
* @param text 文本
* @return boolean 是否为空
*/
public static boolean isNotEmpty(String text)
{
return !isEmpty(text);
}
/**
* 如果文本为空或空字符串，则返回0，否则返回本身
*
* @param text 文本
* @return String 处理后的文本
*/
public static String emptyToZero(String text)
{
String localText = text;
if (isEmpty(text))
{
localText = "0";
}
else
{
localText = text.trim();
}
return localText;
}
/**
* 对象是否为空
*
* @param object 对象
* @return boolean 是否为空
*/
public static boolean isEmpty(Object object)
{
boolean result = false;
if (object != null && !"".equals(object.toString()) && !"null".equals(object.toString()))
{
result = true;
}
return result;
}
/**
* 如果对象为空，则返回默认值，否则强制转换为int类型
*
* @param obj 对象
* @param defaultInt 默认值
* @return int int类型的数字
*/
public static int objectToInt(Object obj, int defaultInt)
{
return obj == null ? defaultInt : ((Integer) obj).intValue();
}
/**
* 如果对象为空，则返回默认值，否则强制转换为String类型
*
* @param obj 对象
* @param defaultStr 默认值
* @return String String对象
*/
public static String objectToString(Object obj, String defaultStr)
{
return obj == null ? defaultStr : String.valueOf(obj);
}
/**
* 如果对象为空，则返回默认值，否则强制转换为Date类型
*
* @param obj 对象
* @param defaultDate 默认值
* @return Date Date对象
*/
public static Date objectToDate(Object obj, Date defaultDate)
{
return obj == null ? defaultDate : (Date) obj;
}
/**
* 如果对象为空，则返回默认值，否则强制转换为double类型的数值
*
* @param obj 对象
* @param defaultDouble 默认值
* @return double double数值
*/
public static double objectToDouble(Object obj, double defaultDouble)
{
return obj == null ? defaultDouble : ((Double) obj).doubleValue();
}
/**
* 如果对象为空，则返回默认值，否则强制转换为long类型的数值
*
* @param obj 对象
* @param defaultLong 默认值
* @return long long数值
*/
public static long objectToLong(Object obj, long defaultLong)
{
return obj == null ? defaultLong : ((Long) obj).longValue();
}
/**
* 如果对象为空，则返回默认值，否则强制转换为boolean类型的数值
*
* @param obj 对象
* @param defaultBoolean 默认值
* @return boolean boolean数值
*/
public static boolean objectToBoolean(Object obj, boolean defaultBoolean)
{
return obj == null ? defaultBoolean : ((Boolean) obj).booleanValue();
}
/**
* 把字符串转换为日期对象，如果字符串为空或格式不符转换失败，则返回null<br/>
* 1.如果字符串长度为8，则按照yyyyMMdd格式进行转换<br/>
* 2.如果字符串长度为10，则按照yyyy-MM-dd格式进行转换<br/>
* 3.如果字符串长度为14，则按照yyyyMMddHHmmss格式进行转换<br/>
* 4.如果字符串长度为19，则按照yyyy-MM-dd HH:mm:ss格式进行转换<br/>
*
* @param dateStr 日期时间字符串
* @return Date 日期对象
*/
public static Date stringToDate(String dateStr)
{
if (dateStr == null || "".equals(dateStr.trim()))
{
return null;
}
String formatStr = "";
if (dateStr.length() == 8)
{
formatStr = "yyyyMMdd";
}
else if (dateStr.length() == 10)
{
formatStr = "yyyy-MM-dd";
}
else if (dateStr.length() == 14)
{
formatStr = "yyyyMMddHHmmss";
}
else if (dateStr.length() == 19)
{
formatStr = "yyyy-MM-dd HH:mm:ss";
}
Date date = null;
try
{
date = new SimpleDateFormat(formatStr).parse(dateStr);
}
catch (ParseException e)
{
e.printStackTrace();
}
return date;
}
/**
* 获取指定格式的日期时间字符串
*
* @param date 日期
* @param dateFormat 日期时间格式
* @return String 日期时间字符串
*/
public static String getDateStr(Date date, String dateFormat)
{
SimpleDateFormat format = new SimpleDateFormat(dateFormat);
String dateStr = format.format(date);
return dateStr;
}
/**
* 获取日期字符串，格式为yyyy-MM-dd
*
* @param date 日期对象
* @return String 日期字符串
*/
public static String getDateStr(Date date)
{
return getDateStr(date, "yyyy-MM-dd");
}
/**
* 获取日期数字字符串，格式为yyyyMMdd
*
* @param date 日期对象
* @return String 日期数字字符串
*/
public static String getDateNumStr(Date date)
{
return getDateStr(date, "yyyyMMdd");
}
/**
* 获取日期时间字符串，格式为yyyy-MM-dd HH:mm:ss
*
* @param date 日期对象
* @return String 日期字符串
*/
public static String getDateTimeStr(Date date)
{
return getDateStr(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* 获取日期时间数字字符串，格式为yyyyMMddHHmmss
*
* @param date 日期对象
* @return String 日期字符串
*/
public static String getDateTimeNumStr(Date date)
{
return getDateStr(date, "yyyyMMddHHmmss");
}
/**
* 根据指定日期格式把日期字符串转换为日期对象
*
* @param dateStr 日期字符串
* @param dateFormat 日期格式
* @return Date 日期对象
*/
public static Date getDate(String dateStr, String dateFormat)
{
Date date = null;
try
{
if (!isEmpty(dateStr))
{
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
date = sdf.parse(dateStr);
}
}
catch (Exception e)
{
e.printStackTrace();
}
return date;
}
/**
* 获取当前时间
*
* @return Date 当前时间
*/
public static Date getCurrentDate()
{
Calendar cal = Calendar.getInstance();
Date currentDate = cal.getTime();
return currentDate;
}
/**
* 获取当前日期的字符串yyyy-MM-dd
*
* @return String 当前日期的数字字符串
*/
public static String getCurrentDateStr()
{
Date date = getCurrentDate();
return getDateStr(date, "yyyy-MM-dd");
}
/**
* 获取当前日期的数字字符串
*
* @return String 当前日期的数字字符串
*/
public static String getCurrentDateNumStr()
{
Date date = getCurrentDate();
return getDateStr(date, "yyyyMMdd");
}
/**
* 获取当前日期时间字符串，格式为yyyy-MM-dd HH:mm:ss
*
* @return String 日期时间字符串
*/
public static String getCurrentDateTimeStr()
{
Date date = getCurrentDate();
return getDateStr(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* 获取当前日期时间数字字符串，格式为yyyyMMddHHmmss
*
* @return String 日期时间字符串
*/
public static String getCurrentDateTimeNumStr()
{
Date date = getCurrentDate();
return getDateStr(date, "yyyyMMddHHmmss");
}
/**
* 比较格式为yyyy-MM-dd HH:mm:ss的日期字符串的大小
*
* @param dateTime1 日期时间字符串1
* @param dateTime2 日期时间字符串2
* @return int 0：相等 1：前者大约后者 -1：前者小于后者 -2：发生错误
*/
public static int compareStringDate(String dateTime1, String dateTime2)
{
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar c1 = Calendar.getInstance();
Calendar c2 = Calendar.getInstance();
try
{
c1.setTime(df.parse(dateTime1));
c2.setTime(df.parse(dateTime2));
}
catch (ParseException e)
{
return -2;
}
int result = c1.compareTo(c2);
if (result == 0)
{
return 0;
}
return result >= 0 ? 1 : -1;
}
/**
* 是否为数字
*
* @param text 要验证的文本
* @return boolean true-是 false-否
*/
public static boolean isNumber(String text)
{
if (isEmpty(text))
{
return false;
}
String numberStr = "0123456789";
for (int i = 0; i < text.length(); i++)
{
char c = text.charAt(i);
if (numberStr.indexOf(String.valueOf(c)) == -1)
{
return false;
}
}
return true;
}
/**
* 是否符合电子邮件地址格式
*
* @param email 电子邮件地址
* @return boolean true-是 false-否
*/
public static boolean isEmail(String email)
{
boolean isEmail = false;
Pattern p = Pattern.compile("([\\w[.-]]+)(@)([\\w[.-]]+\\.[\\w[.-]]+)");
Matcher m = p.matcher(email);
if (m.matches())
{
isEmail = true;
}
return isEmail;
}
/**
* 是否符合手机号码格式
*
* @param mobile 手机号码
* @return boolean true-是 false-否
*/
public static boolean isMobile(String mobile)
{
boolean isMobile = false;
Pattern p = Pattern.compile("((\\()?(\\+)?(86)?1[3|5|8][0-9]{9}(\\))?$)|((\\()?(\\+)?(86)?01[3|5|8][0-9]{9}(\\))?$)");
Matcher m = p.matcher(mobile);
if (m.matches())
{
isMobile = true;
}
return isMobile;
}
/**
* 电话号码格式简单校验，格式为：数字-数字
*
* @param phone 电话号码
* @return boolean true-是 false-否
*/
public static boolean isPhone(String phone)
{
boolean isPhone = false;
int index = phone.indexOf("-");
if (index > 0 && index != phone.length() - 1)
{
String phoneNum = phone.substring(0, index) + phone.substring(index + 1);
if (isNumber(phoneNum))
{
isPhone = true;
}
}
return isPhone;
}
/**
* 是否为密码，允许大小写字母、数字以及下划线，长度为4-16位
*
* @param pwd 密码
* @return boolean true-是 false-否
*/
public static boolean isPassword(String pwd)
{
boolean ifPwd = false;
Pattern p = Pattern.compile("([A-Za-z0-9_]{4,16})");
Matcher m = p.matcher(pwd);
if (m.matches())
{
ifPwd = true;
}
return ifPwd;
}
/**
* 文本是否都有字母组成
*
* @param text 待验证的文本
* @return boolean true-是 false-否
*/
public static boolean isLetter(String text)
{
if (text != null)
{
Pattern pattern = Pattern.compile("^[a-zA-Z]+$");
Matcher matcher = pattern.matcher(text);
if (matcher.matches())
{
return true;
}
}
return false;
}
/**
* 是否为文字，包括中文字符、英文字母和数字
*
* @param text 待验证的文本
* @return boolean true-是 false-否
*/
public static boolean isWord(String text)
{
boolean isWord = false;
if (text != null)
{
Pattern p = Pattern.compile("([A-Za-z0-9\u4E00-\u9FA5])+");
Matcher m = p.matcher(text);
if (m.matches())
{
isWord = true;
}
}
return isWord;
}
/**
* 字符串是否处于指定长度之间
*
* @param text 文本
* @param minLen 最小长度
* @param maxLen 最大长度
* @return boolean true-是 false-否
*/
public static boolean isLength(String text, int minLen, int maxLen)
{
int length = 0;
if (text != null)
{
length = trueLength(text);
}
boolean result = false;
if (length >= minLen && length <= maxLen)
{
result = true;
}
return result;
}
/**
* 获取文本的真实长度，中文-2 英文-1
*
* @param text 文本
* @return int 文本的真实长度
*/
public static int trueLength(String text)
{
int length = 0;
Pattern p = Pattern.compile("([\u4E00-\u9FA5])");
for (int i = 0; i < text.length(); i++)
{
Matcher m = p.matcher(text.charAt(i) + "");
if (m.matches())
{
length += 2;
}
else
{
length++;
}
}
return length;
}
/**
* 检查是否符合昵称规则，4-24个字符, 支持中英文、数字、下划线;<br/>
*
* @param nickName 昵称
* @return boolean true-符合 false-不符合
*/
public static boolean isNickName(String nickName)
{
int length = trueLength(nickName);
if (length < 4 || length > 24)
{
return false;
}
Pattern p = Pattern.compile("([_A-Za-z0-9\u4E00-\u9FA5]){1,24}");
Matcher m = p.matcher(nickName);
if (!m.matches())
{
return false;
}
return true;
}
/**
* 是否URL地址
*
* @param url URL
* @return boolean true-是 false-否
*/
public static boolean isUrl(String url)
{
return validByRegex("(http://|https://)?([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?", url);
}
/**
* 是否为数字字符串
*
* @param s 字符串
* @return boolean true-是 false-否
*/
public static boolean isNumberic(String s)
{
if (isEmpty(s))
{
return false;
}
boolean rtn = validByRegex("^[-+]{0,1}\\d*\\.{0,1}\\d+$", s);
if (rtn)
{
return true;
}
return validByRegex("^0[x|X][\\da-eA-E]+$", s);
}
/**
* 是否为整数字符串
*
* @param s 字符串
* @return boolean true-是 false-否
*/
public static boolean isInteger(String s)
{
boolean result = validByRegex("^[-+]{0,1}\\d*$", s);
return result;
}
/**
* 是否为邮政编码
*
* @param s 字符串
* @return boolean true-是 false-否
*/
public static boolean isZipCode(String s)
{
boolean result = validByRegex("^[0-9]{6}$", s);
return result;
}
/**
* 是否为QQ号码
*
* @param s 字符串
* @return boolean true-是 false-否
*/
public static boolean isQq(String s)
{
boolean result = validByRegex("^[1-9]\\d{4,9}$", s);
return result;
}
/**
* 是否为指定格式的日期字符串
*
* @param strDate 日期字符串
* @param format 日期格式
* @return boolean true-是 false-否
*/
public static boolean isDate(String strDate, String format)
{
boolean result = false;
try
{
DateFormat df = new SimpleDateFormat(format);
Date d = df.parse(strDate);
String strNewDate = df.format(d);
if (strDate.equals(strNewDate))
{
result = true;
}
}
catch (Exception localException)
{
}
return result;
}
/**
* 检验字符串是否匹配指定的正则表达式
*
* @param regex 正则表达式
* @param input 字符串
* @return boolean true-匹配 false-不匹配
*/
public static boolean validByRegex(String regex, String input)
{
Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher regexMatcher = p.matcher(input);
return regexMatcher.find();
}
/**
* 数组拼装成 xx,yy,zz
*
* @param array 数组
* @param separator 分隔符
* @return String 字符串
*/
public static <T> String join(T[] array, String separator)
{
StringBuffer str = new StringBuffer();
String newStr = "";
if (array != null && array.length > 0)
{
for (T arr : array)
{
str.append(arr).append(separator);
}
newStr = str.substring(0, str.length() - 1);
}
return newStr;
}
/**
* 列表拼装成 xx,yy,zz类型的字符串
*
* @param list 列表
* @param separator 分隔符
* @return String 字符串
*/
public static <T> String join(List<T> list, String separator)
{
StringBuffer str = new StringBuffer();
String newStr = "";
if (list != null && list.size() > 0)
{
for (T arr : list)
{
str.append(arr).append(separator);
}
newStr = str.substring(0, str.length() - 1);
}
return newStr;
}
/**
* 转换为大写
*
* @param str 字符串
* @return String 大写字符串
*/
public static String upperCase(String str)
{
if (str == null)
{
return null;
}
return str.toUpperCase();
}
/**
* 转换为小写
*
* @param str 字符串
* @return String 小写字符串
*/
public static String lowerCase(String str)
{
if (str == null)
{
return null;
}
return str.toLowerCase();
}
/**
* 字符串是否为null或者由空白字符组成
*
* @param str 字符串
* @return boolean true-是 false-否
*/
public static boolean isBlank(String str)
{
if ((str == null) || str.length() == 0)
{
return true;
}
int strLen = str.length();
for (int i = 0; i < strLen; i++)
{
if (!Character.isWhitespace(str.charAt(i)))
{
return false;
}
}
return true;
}
/**
* 字符串是否不为null并且不都由空白字符组成
*
* @param str 字符串
* @return boolean true-是 false-否
*/
public static boolean isNotBlank(String str)
{
return !isBlank(str);
}
/**
* 提供精确的小数位四舍五入处理
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return double 四舍五入后的结果
*/
public static double round(double v, int scale)
{
if (scale < 0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的加法运算
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指定的精度，以后的数字四舍五入
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale)
{
if (scale < 0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 获取有★组成的字符串，如：★★★，如果starCount小于等于0，返回空字符串
*
* @param starCount 星星的数量
* @return String starCount个星星组成的字符串
*/
public static String getStarString(int starCount)
{
String starString = "";
if (starCount > 0)
{
for (int i = 0; i < starCount; i++)
{
starString += "★";
}
}
return starString;
}
/**
* 根据类名获取Class类
*
* @param className 全类名
* @return Class<?> Class类
* @throws ClassNotFoundException
*/
public static Class<?> getClass(String className) throws ClassNotFoundException
{
return Class.forName(className);
}
/**
* 是否存在类名指定的类
*
* @param className 类名
* @return boolean true-存在 false-不存在
*/
public static boolean hasClass(String className)
{
boolean has = true;
try
{
Class.forName(className);
}
catch (ClassNotFoundException e)
{
has = false;
}
return has;
}
/**
* 获取类的构造器
*
* @param c 类
* @param parameterTypes 参数类型
* @return Constructor<?> 构造器
* @throws SecurityException
* @throws NoSuchMethodException
*/
public static Constructor<?> getConstructor(Class<?> c, Class<?>[] parameterTypes) throws SecurityException, NoSuchMethodException
{
return c.getConstructor(parameterTypes);
}
/**
* 根据Class类获取类名
*
* @param c Class类
* @return String 类名
*/
public static String getClassName(Class<?> c)
{
String className = c.getSimpleName();
Class<?>[] interfaces = c.getInterfaces();
if ((!className.startsWith("$")) || (interfaces.length == 0))
{
return className;
}
String[] names = new String[interfaces.length];
for (int i = 0; i < interfaces.length; i++)
{
names[i] = interfaces[i].getSimpleName();
}
return className + "(" + join(names, ",") + ")";
}
/**
* SQL特殊字符转义
*
* @param sql 结构化查询语句
* @return String 转义后的SQL
*/
public static String encodeSQL(String sql)
{
if (sql == null)
{
return "";
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sql.length(); i++)
{
char c = sql.charAt(i);
switch (c)
{
case '\\':
sb.append("\\\\");
break;
case '\r':
sb.append("\\r");
break;
case '\n':
sb.append("\\n");
break;
case '\t':
sb.append("\\t");
break;
case '\b':
sb.append("\\b");
break;
case '\'':
sb.append("''");
break;
case '"':
sb.append("\\\"");
break;
case '%':
sb.append("\\%");
break;
default:
sb.append(c);
}
}
return sb.toString();
}
/**
* MD5散列不可逆加密算法
*
* @param userName 用户名
* @param password 密码
* @return String 加密后的密码
*/
public static String encryptPassword(String userName, String password)
{
String publicKey1 = "jjejduuhjdjdHDUEHWHd3ehgfidhwh23hHJCRIOI4HDHDHFKHFD3dhdhrg2djsHSDFHFEDJGW";
String publicKey2 = "347djejDETahe3j%3jd*%%2DDE223fdhahfh%^@21hdhfhzhdDFQ3hH7eh32hdE#@sdqhqhde";
String publicKey3 = "wkjd@wjsdj2324shjsQWeh2dsGed/#21ssdEdhawehrcyzhzeje2#@SDajw2D2sjzahd3#dSa";
String str = publicKey1 + userName + publicKey2 + password + publicKey3;
return md5(str).toUpperCase();
}
/**
* 使用UTF-8解码字符串
*
* @param paramValue 参数字符串
* @return String 解码后的字符串
* @throws Exception
*/
public static String decodeUTF8(String str)
{
return decode(str, "utf-8");
}
/**
* 用指定的编码类型对字符串进行解码
*
* @param string 字符串
* @param encodeScheme 编码类型
* @return String 解码后的字符串
*/
public static String decode(String string, String encodeScheme)
{
try
{
return java.net.URLDecoder.decode(string, encodeScheme);
}
catch (UnsupportedEncodingException uee)
{
uee.printStackTrace();
}
return string;
}
/**
* 使用UTF-8编码字符串
*
* @param paramValue 参数字符串
* @return String 编码后的字符串
* @throws Exception
*/
public static String encodeUTF8(String str)
{
return encode(str, "utf-8");
}
/**
* 用指定的编码类型对字符串进行编码
*
* @param string 字符串
* @param encodeScheme 编码类型
* @return String 编码后的字符串
*/
public static String encode(String string, String encodeScheme)
{
try
{
return java.net.URLEncoder.encode(string, encodeScheme);
}
catch (UnsupportedEncodingException uee)
{
uee.printStackTrace();
}
return string;
}
/**
* 数组转换为列表
*
* @param array 数组
* @return List<T> 列表
*/
public static <T> List<T> arrayToList(T[] array)
{
List<T> list = null;
if (array != null)
{
list = new ArrayList<T>();
for (int i = 0; i < array.length; i++)
{
list.add(array[i]);
}
}
return list;
}
/**
* 列表转换为数组
*
* @param list 列表
* @param type Class类型
* @return T[] 数组
*/
@SuppressWarnings("unchecked")
public static <T> T[] listToArray(List<T> list, Class<T> type)
{
T[] array = null;
if (list != null)
{
array = (T[]) Array.newInstance(type, list.size());
for (int i = 0; i < list.size(); i++)
{
array[i] = list.get(i);
}
}
return array;
}
/**
* 把字符串由一种编码转换为另一种编码(如果转换失败，则返回原字符串)
*
* @param str 字符串
* @param from 源编码
* @param to 目标编码
* @return String 编码后的字符串
*/
public static String encodingString(String str, String from, String to)
{
String result = str;
try
{
result = new String(str.getBytes(from), to);
}
catch (Exception e)
{
result = str;
}
return result;
}
/**
* MD5加密字符串
*
* @param str 加密前的字符串
* @return String 加密后的字符串
*/
public static String md5(String str)
{
try
{
MessageDigest alg = MessageDigest.getInstance("MD5");
byte[] b = str.getBytes();
alg.reset();
alg.update(b);
byte[] hash = alg.digest();
String d = "";
for (int i = 0; i < hash.length; i++)
{
int v = hash[i] & 0xFF;
if (v < 16)
{
d += "0";
}
d += Integer.toString(v, 16);
}
return d;
}
catch (NoSuchAlgorithmException e)
{
return null;
}
}
/**
* 关闭数据库连接
*
* @param conn 数据库连接
*/
public static void closeConnection(Connection conn)
{
try
{
if ((conn != null) && (!conn.isClosed()))
{
conn.close();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 关闭Statement对象
*
* @param stmt Statement对象
*/
public static void closeStatement(Statement stmt)
{
try
{
if (stmt != null)
{
stmt.close();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 关闭结果集
*
* @param rs ResultSet对象
*/
public static void closeResultSet(ResultSet rs)
{
try
{
if (rs != null)
{
rs.close();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 安全关闭数据库连接、Statement及结果集对象
*
* @param conn 数据库连接对象
* @param stmt Statement对象
* @param rs 结果集对象
*/
public static void close(Connection conn, Statement stmt, ResultSet rs)
{
closeResultSet(rs);
closeStatement(stmt);
closeConnection(conn);
}
/**
* 回滚数据库事务
*
* @param conn 数据库连接
*/
public static void rollback(Connection conn)
{
try
{
if ((conn != null) && (!conn.isClosed()))
{
conn.rollback();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 是否为自动提交
*
* @param conn 数据库连接
* @return boolean true-是 false-否
*/
public static boolean isAutoCommit(Connection conn)
{
try
{
if ((conn != null) && (!conn.isClosed()))
{
return conn.getAutoCommit();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
return false;
}
/**
* Connection对象不为null且未关闭的情况下，设置是否自动提交
*
* @param conn 数据库连接
* @param autoCommit 是否自动提交
*/
public static final void setAutoCommit(Connection conn, boolean autoCommit)
{
try
{
if ((conn != null) && (!conn.isClosed()))
{
conn.setAutoCommit(autoCommit);
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 提交数据库事务
*
* @param conn Connection对象
*/
public static void commit(Connection conn)
{
try
{
if ((conn != null) && (!conn.isClosed()))
{
conn.commit();
}
}
catch (SQLException e)
{
e.printStackTrace();
}
}
}
JAVA项目开发中常用的工具方法
猜你喜欢
转载自tuozixuan.iteye.com/blog/2251319
今日推荐
周排行