系统常用工具类

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;
import javax.servlet.http.HttpServletRequest;

import com.*.snp.baseapp.common.constants.SysConstants;
import com.*.snp.baseapp.model.LoginInfo;

/**
 * 类 编 号: SNP_CJ001_SysUtils
 * 类 名 称: SysUtils
 * 内容摘要: 系统常用工具类
 * 完成日期: 2007-11-14
 * 编码作者: *
 */
public class SysUtils
{
    //private static final Logger log = Logger.getLogger(SysUtils.class);


    /**
     * 设置当前登录信息到Session中
     *
     * @param request   HttpServletRequest
     * @param loginInfo 登录信息
     */
    public static void setCurrUserSession(HttpServletRequest request, LoginInfo loginInfo)
    {
        request.getSession().setAttribute(SysConstants.SESSION_USER_INDEX, loginInfo);
    }

    /**
     * 得到当前登录信息（From Session）
     *
     * @param request HttpServletRequest
     * @return 登录信息
     */
    public static LoginInfo getCurrUserSession(HttpServletRequest request)
    {
        LoginInfo loginInfo = (LoginInfo) request.getSession().getAttribute(SysConstants.SESSION_USER_INDEX);
        if(loginInfo == null)
        {
            loginInfo = new LoginInfo("admin", "admin", "系统管理员");  //测试用，正式使用时需要注释掉
        }
        return loginInfo;
    }

    /**
     * 得到当前登录用户的UserID（From Session）
     *
     * @param request HttpServletRequest
     * @return 用户账号ID，如果没有登录，则返回“”空字符串
     */
    public static String getCurrUserID(HttpServletRequest request)
    {
        LoginInfo loginInfo = getCurrUserSession(request);
        if(loginInfo == null)
        {
            return "";
        }

        return loginInfo.getUserID();
    }

    /**
     * 从Session中移除当前登录信息
     *
     * @param request HttpServletRequest
     */
    public static void removeUserSession(HttpServletRequest request)
    {
        request.getSession().removeAttribute(SysConstants.SESSION_USER_INDEX);
    }

    /**
     * 得到当前访问的地址
     *
     * @param request HttpServletRequest
     * @return URL
     */
    public static String getAccessUrl(HttpServletRequest request)
    {
        StringBuilder sb = new StringBuilder("http://");
        sb.append(request.getRemoteAddr());
        int port = request.getRemotePort();
        if(port != 80)
        {
            sb.append(":").append(port);
        }
        sb.append("/").append(request.getContextPath());
        return sb.toString();
    }

    /**
     * 获得当前日期和时间
     *
     * @return String 当前日期和时间，格式：yyyy-MM-dd HH:mm:ss
     */
    public static String getCurDateTime()
    {
        SimpleDateFormat nowDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return nowDate.format(new Date());
    }

    /**
     * 获得当前日期
     *
     * @return String 当前日期，格式：yyyy-MM-dd
     */
    public static String getCurDate()
    {
        SimpleDateFormat nowDate = new SimpleDateFormat("yyyy-MM-dd");
        return nowDate.format(new Date());
    }


    /**
     * 将日期时间转换成yyy-MM-dd HH:mm:ss的格式
     *
     * @param date Date 要转换的日期时间
     * @return String 转换后的日期时间
     */
    public static String getDateTime(Date date)
    {
        SimpleDateFormat nowDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return nowDate.format(date);
    }

    /**
     * 将日期转换成yyy-MM-dd的格式
     *
     * @param date Date 要转换的日期
     * @return String 转换后的日期
     */
    public static String getDate(Date date)
    {
        if(date == null)
        {
            return "";
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);
    }


    /**
     * 将日期时间转换成 pattern 格式的时间
     *
     * @param date    Date 要转换的日期时间
     * @param pattern 时间模式 为null时默认为“yyy-MM-dd HH:mm:ss”
     * @return String 转换后的日期时间
     */
    public static String getDateTime(Date date, String pattern)
    {
        if(pattern == null)
        {
            pattern = "yyyy-MM-dd HH:mm:ss";
        }
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.format(date);
    }

    /**
     * 字符串转化为日期
     *
     * @param str String
     * @return Date 日期
     */
    public static Date StrToDate(String str)
    {
        Date returnDate = null;
        if(str != null)
        {
            DateFormat df = DateFormat.getDateInstance();
            try
            {
                returnDate = df.parse(str);
            }
            catch(Exception e)
            {
                System.err.println("AppTools [Date StrToDate(String str)] Exception");
                return returnDate;
            }
        }
        return returnDate;
    }

    /**
     * 字符串转换为日期（包含小时分）
     *
     * @param str     字符串
     * @param pattern 时间模式 为null时默认为“yyy-MM-dd HH:mm:ss”
     * @return Date
     */
    public static Date StrToDateTime(String str, String pattern)
    {
        Date returnDate = null;
        if(pattern == null)
        {
            pattern = "yyyy-MM-dd HH:mm:ss";
        }

        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        try
        {
            returnDate = sdf.parse(str);
        }
        catch(Exception e)
        {
            return returnDate;
        }
        return returnDate;
    }

    /**
     * 字符串转换为整数
     *
     * @param str String 要转换的字符串
     * @return int 转换后的整数
     */
    public static int getInt(String str)
    {
        if((str != null) && (!"".equals(str)))
        {
            if(str.charAt(0) == '+')//带正负号的数也有效
            {
                str = str.substring(1);
            }
            try
            {
                return Integer.parseInt(str);
            }
            catch(Exception e)
            {
                return 0;//转换错误时，返回0
            }
        }
        else
        {
            //字符串为空时返回0
            return 0;
        }
    }

    /**
     * 字符串转换为长整数
     *
     * @param str String 要转换的字符串
     * @return long 转换后的长整数
     */
    public static long getLong(String str)
    {
        if((str != null) && (!"".equals(str)))
        {
            if(str.charAt(0) == '+')//带正负号的数也有效
            {
                str = str.substring(1);
            }
            try
            {
                return Long.parseLong(str);
            }
            catch(Exception e)
            {
                return 0;//转换错误时，返回0
            }
        }
        else
        {
            //字符串为空时返回0
            return 0;
        }
    }

    /**
     * 字符串转换为double
     *
     * @param str String 要转换的字符串
     * @return double 转换后的double
     */
    public static double getDouble(String str)
    {
        if(str != null && !"".equals(str))
        {
            try
            {
                return Double.parseDouble(str);
            }
            catch(Exception e)
            {
                return 0;//转换错误时返回0
            }
        }
        else
        {
            //字符串为空时，返回0
            return 0;
        }
    }

    /**
     * 去掉字符串两边的空格，为空时返回“”
     *
     * @param str 字符串
     * @return String
     */
    public static String trim(String str)
    {
        if(str == null)
        {
            return "";
        }
        else
        {
            return str.trim();
        }
    }

    /**
     * 取字符串的固定长度部分,用"..."结尾
     *
     * @param src 源字符串
     * @param len 截取长度
     * @return 截取后的字符串
     */
    public static String getSizedString(String src, int len)
    {
        if(src == null)
        {
            return "";
        }

        if(src.length() <= len)
        {
            return src;
        }

        String str = src.substring(0, len);
        str += "...";
        return str;
    }

    private static final char[] zeroArray = "00000000000000000000".toCharArray();

    /**
     * 将字符串的左边补充0
     *
     * @param string String 要补充的字符串
     * @param length int 补0后的位数，最长20位
     * @return String 补0后的字符串
     */
    public static final String zeroPadString(String string, int length)
    {
        if(string == null || string.length() > length)
        {
            return string;
        }
        StringBuffer buf = new StringBuffer(length);
        buf.append(zeroArray, 0, length - string.length()).append(string);
        return buf.toString();
    }


    /**
     * 判断一个字符串是否为 null 或 为空串.
     *
     * @param str 待判断字符串
     * @return 返回true假如字符串为null或为空串
     */
    public static boolean isEmpty(final String str)
    {
        return str == null || str.length() == 0;
    }

    /**
     * 判断一个字符串是否 空白 或 为null 或 为空串.
     *
     * @param str 待判断字符串
     * @return 返回true假如字符串为空白或为null或为空串
     */
    public static boolean isBlank(final String str)
    {

        if(isEmpty(str))
            return true;

        for(char c : str.toCharArray())
        {
            if(!Character.isWhitespace(c))
                return false;
        }

        return true;
    }

    /**
     * 将一个字符串按指定的编码格式进行转换
     *
     * @param str         String 要转换的字符串
     * @param charsetFrom 原始编码，如：GBK， UTF-8， iso8859_1，如果为null则为默认字符编码
     * @param charsetTo   待转向的编码，如：GBK， UTF-8， iso8859_1，如果为null则返回原始字符串
     * @return String
     */
    public static String encodeString(String str, String charsetFrom, String charsetTo)
    {
        if(str == null || str.length() == 0)
        {
            return "";
        }

        if(charsetTo == null)
        {
            return str;
        }

        String temp;
        try
        {
            byte[] buf = (charsetFrom != null) ? str.getBytes(charsetFrom) : str.getBytes();
            temp = new String(buf, charsetTo);
        }
        catch(Exception e)
        {
            // 转换错误时，返回原字符串
            temp = str;
        }
        return temp;
    }

    /**
     * 通配符匹配，支持*，?
     *
     * @param patten 通配符模式
     * @param str    待匹配的字符串
     * @return 匹配成功则返回true,否则返回false
     */
    public static boolean wildcardMatch(String patten, String str)
    {
        if(patten == null || str == null)
        {
            return false;
        }

        int pattenLength = patten.length();
        int strLength = str.length();
        int strIndex = 0;
        char ch;
        for(int pattenIndex = 0; pattenIndex < pattenLength; pattenIndex++)
        {
            ch = patten.charAt(pattenIndex);
            if(ch == '*')
            {
                // 通配符*可以匹配任意多个字符
                while(strIndex < strLength)
                {
                    if(wildcardMatch(patten.substring(pattenIndex + 1), str.substring(strIndex)))
                    {
                        return true;
                    }
                    strIndex++;
                }

            }
            else if(ch == '?')
            {
                // //通配符?可以匹配任意一个字符
                strIndex++;
                if(strIndex > strLength)
                {
                    // 表示str中已经没有字符匹配“?“了
                    return false;
                }
            }
            else
            {
                if(strIndex >= strLength || ch != str.charAt(strIndex))
                {
                    return false;
                }
                strIndex++;
            }
        }
        return (strIndex == strLength);
    }

    /**
     * 格式化日期，将日期从yyyyMMddHHmmss转换为yyyy-MM-dd HH:mm:ss
     *
     * @param strDateTime String
     * @return String
     */
    public static String formatDate(String strDateTime)
    {
        try
        {
            SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
            Date date1 = df.parse(strDateTime);
            df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            strDateTime = df.format(date1);
        }
        catch(Exception ex)
        {
            strDateTime = "";
        }
        return strDateTime;
    }


    /**
     * 将字符串按分隔符转换为ArrayList对象
     *
     * @param str       String 要转换的字符串
     * @param separator String 分隔符
     * @return ArrayList
     */
    public static List<String> getStringToken(String str, String separator)
    {
        StringTokenizer st = new StringTokenizer(str, separator);
        List<String> lists = new ArrayList<String>();
        String tmp;
        while(st.hasMoreTokens())
        {
            tmp = st.nextToken().trim();
            if(!"".equals(tmp))
            {
                lists.add(tmp);
            }
        }
        return lists;
    }
}