配置文件 property 处理工具 类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropsUtils {
    //日志
    private static final Logger LoggER = LoggerFactory.getLogger(PropsUtils.class);

    /**
     * 加载属性文件
     */
    public static Properties loadProps(String fileName) {
        Properties properties = null;
        InputStream is = null;
        try {
            is = Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream(fileName);
            if (is == null) {
                throw new FileNotFoundException(fileName + "filename");

            }
            properties = new Properties();
            properties.load(is);
        } catch (IOException e) {
            LoggER.error("load properties file failure", e);
        } finally {
            if (is != null){
                try {
                    is.close();
                    is=null;
                }catch (Exception e){
                    LoggER.error("close inputstream failure "+e);
                }
            }
        }
        return properties;
    }

    /**
     * 获取字符串属性 默认为空值
     * @param properties
     * @param key
     * @return
     */
    public static String getString(Properties properties,String key){
        return  getString(properties,key,"");
    }

    /**
     *  获取字符型属性 可指定默认值
     * @param properties
     * @param key
     * @param defaultValue
     * @return
     */
    public static String getString(Properties properties,String key,String defaultValue){
        String value = defaultValue;
        if(properties.containsKey(key)){
            value = properties.getProperty(key);
        }
        return value;
    }

    /**
     * 获取数值属性 默认为0
     * @param properties
     * @param key
     * @return
     */
    public  static  int getInt(Properties properties,String key){
        return getInt(properties,key,0);
    }
    /***
     * 获取配置文件 数字型 属性
     * @param properties
     * @param key
     * @param defaultValue
     * @return
     */
     public  static  int getInt(Properties properties,String key,int defaultValue){
        int value = defaultValue;
        if(properties.containsKey(key)){
            value = CastUtil.castInt(properties.getProperty(key));
        }
        return  value;
     }

    /**
     * 获取boolean型属性值，默认为false
     * @param properties
     * @param key
     * @return
     */
     public  static boolean getBoolean(Properties properties,String key){
         return  getBoolean(properties,key,false);
     }
    /**
     * 获取boolean型属性配置 可指定默认值
     * @param properties
     * @param key
     * @param defaultValue
     * @return
     */
     public static boolean getBoolean(Properties properties,String key,boolean defaultValue){
         boolean value = defaultValue;
         if(properties.containsKey(key)){
             value =CastUtil.castBoolean(properties.getProperty(key));
         }
         return  value;
     }

}

/**
 * 类型转换工具 为 PropsUtils服务
 */
public class CastUtil {

    /**
     * 转化为 String 默认值为空
     * @param obj
     * @return
     */
    public  static  String castString(Object obj){
        return castString(obj,"");
    }
    /**
     * 转为 String 可指定默认值
     * @param obj
     * @param defaultValue
     * @return
     */
    public  static String  castString(Object obj,String defaultValue){
        return obj != null ? String.valueOf(obj) : defaultValue;
    }

    /**
     * 转化为 int型 默认为0；
     * @param obj
     * @return
     */
    public static  int castInt(Object obj){
        return castInt(obj,0);
    }
    /**
     * 转化为 int型 待默认值
     *
     */
    public  static  int castInt(Object obj,int defaultValue){
        int intValue = defaultValue;
        if(obj !=null){
            String strValue = castString(obj);
            if(StringUtil.isNotEmpty(strValue)){
                try{
                    intValue= Integer.parseInt(strValue);
                }catch (Exception e){
                    intValue = defaultValue;
                }
            }
        }
        return  intValue;
    }
    /**
     * 转化为 long型 默认为0；
     * @param obj
     * @return
     */
    public static  long castLong(Object obj){
        return castLong(obj,0);
    }

    /**
     * 转为 long型  提供默认值
     * @param obj
     * @param defaultValue
     * @return
     */
    public  static  long castLong(Object obj,long defaultValue){
        long longValue = defaultValue;
        if(obj !=null){
            String strValue = castString(obj);
            if(StringUtil.isNotEmpty(strValue)){
                try{
                    longValue= Long.parseLong(strValue);
                }catch (Exception e){
                    longValue = defaultValue;
                }
            }
        }
        return  longValue;
    }
    /**
     * 转化为 double型 默认为0；
     * @param obj
     * @return
     */
    public static  double castDouble(Object obj){
        return castDouble(obj,0);
    }
    /**
     * 转为 double型  提供默认值
     * @param obj
     * @param defaultValue
     * @return
     */
    public  static  double castDouble(Object obj,double defaultValue){
        double doubleValue = defaultValue;
        if(obj !=null){
            String strValue = castString(obj);
            if(StringUtil.isNotEmpty(strValue)){
                try{
                    doubleValue = Double.parseDouble(strValue);
                }catch (Exception e){
                    doubleValue  = defaultValue;
                }
            }
        }
        return  doubleValue ;
    }



    /**
     * 获取boolean 属性 默认值为 false;
     * @param obj
     * @return
     */
    public static boolean castBoolean(Object obj){
        return castBoolean(obj,false);
    }
    /**
     * 获取boolean 型属性 待默认值
     * @param obj
     * @param defultValue
     * @return
     */
    public static  boolean castBoolean(Object obj,Boolean defultValue){
        boolean value = defultValue;
        if(obj != null){
          value = Boolean.parseBoolean(castString(obj));
        }
        return value;
    }

}

import org.apache.commons.lang3.StringUtils;

/**
 * 字符串工具类
 */
public class StringUtil {

    public static boolean isEmpty(String str){
        if(str != null){
            str =str.trim();
        }
        return StringUtils.isEmpty(str);
    }

    public  static boolean isNotEmpty(String str){
        return !isEmpty(str);
    }

}