服务启动初始化相关配置 如XML、properties、log等文件 /** * */ package com.companyName.dhm.common.init; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.InputStreamReader; import java.util.Iterator; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import javax.servlet.ServletContext; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.companyName.dhm.common.config.impl.ConfigFactory; import com.companyName.dhm.common.log.config.Log4jConfigurer; import com.companyName.dhm.common.uif.config.EndpointItem; import com.companyName.dhm.common.uif.config.SystemConfig; import com.companyName.dhm.report.service.ReportService; /** * @author * */ public class InitSystemListener implements ServletContextListener { ReportService reportService; /* * (non-Javadoc) * * @see javax.servlet.ServletContextListener#contextDestroyed(javax.servlet.ServletContextEvent) */ public void contextDestroyed(ServletContextEvent sce) { // TODO Auto-generated method stub } /* * (non-Javadoc) * * @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent) */ public void contextInitialized(ServletContextEvent sce) { String FS = System.getProperty("file.separator"); ServletContext ctx = sce.getServletContext(); // invoke system initial filter System.out.println("========================"); System.out.println("BI: Initial system..."); SystemInitiator.initApp(ctx); // print welcome.txt System.out.println("BI: welcome info"); printWelcome(ctx.getInitParameter("system.welcome-file-name")); // print version info System.out.println("BI: version info"); VersionInfo.init(ctx.getInitParameter("system.version-file-name")); System.out.println(VersionInfo.getVersionInfo()); // initial log configuration System.out.println("BI: Initial log..."); String logFile = ctx.getInitParameter("log.config-file"); if (logFile == null || logFile.trim().length() == 0) { System.out.println("BI: log.config-file is not configed,so not initial!!! "); } else { String logConfigFileLocation = SystemInitiator.getSystemInfo() .getConfPath() + FS + logFile; try { int refreshInterval = Integer.parseInt(ctx .getInitParameter("log.config-file-refresh-interval")); System.out.println("logConfigFileLocation=" + logConfigFileLocation + ",refreshInterval=" + refreshInterval); Log4jConfigurer.initLogging(logConfigFileLocation,refreshInterval); } catch (Exception e) { System.out.println("BI: Initail log4f config error:" + e.getMessage()); System.exit(1); } } // Initial License // System.out.println("BI: Initial license..."); // String licenseFileName = ctx.getInitParameter("license.license-file"); // String publicKeyFileName = ctx // .getInitParameter("license.public-key-file"); // new com.companyName.dhm.common.license.LicenseInit().init(licenseFileName,// publicKeyFileName); // initial log configuration System.out.println("BI: Initial system configuration..."); String configFile = ctx.getInitParameter("config.system-config-file"); if (configFile == null || configFile.trim().length() == 0) { System.out.println("BI: config.system-config-file is not configed,so not initial!!! "); } else { new ConfigFactory().initConfig(SystemInitiator.getSystemInfo() .getConfPath(),configFile); } ApplicationContext appctx=null; System.out.println("Update VOD record valid Time"); appctx = new ClassPathXmlApplicationContext(new String[]{"spring/applicationcontext-datasource.xml","spring/applicationcontext-report.xml","spring/applicationcontext-adminmanage.xml","spring/applicationcontext-logmanage.xml","spring/applicationcontext-rolemanage.xml"}); reportService = (ReportService) appctx.getBean("ReportService"); String validTimeStr = ctx.getInitParameter("system.configValidTime-file-name"); System.out.println("Read validTimeStr>>>>>"+validTimeStr); int validTime = Integer.parseInt(getValidTime(validTimeStr)); reportService.updateValidTime(validTime); System.out.println("Update VOD record valid Time["+validTime+"]"); } private void printWelcome(String welcomeFileName) { String FS = System.getProperty("file.separator"); String welcomeFile = SystemInitiator.getSystemInfo().getConfPath() + FS + welcomeFileName; File file = new File(welcomeFile); try { FileReader fileReader = new FileReader(file); BufferedReader br = new BufferedReader(fileReader); StringBuffer sb = new StringBuffer(100); String str; boolean firstLine = true; while ((str = br.readLine()) != null) { if (firstLine) { sb.append(str); firstLine = false; } else { sb.append("\n").append(str); } } System.out.println(sb.toString()); br.close(); fileReader.close(); } catch (Exception e) { System.out .println("BI: Read welcome file error:" + e.getMessage()); } } private String getValidTime(String FileName) { String FS = System.getProperty("file.separator"); String welcomeFile = SystemInitiator.getSystemInfo().getConfPath() + FS + FileName; File file = new File(welcomeFile); String lineTxt = null; String defaultValue = "600"; StringBuffer sb = new StringBuffer(); try { String encoding = "UTF-8"; if (file.isFile() && file.exists()) { // 判断文件是否存在 InputStreamReader read = new InputStreamReader( new FileInputStream(file),encoding);// 考虑到编码格式 BufferedReader bufferedReader = new BufferedReader(read); while ((lineTxt = bufferedReader.readLine()) != null) { sb.append(lineTxt); } read.close(); //System.out.println("读取到的数值>>>>" + sb.toString()); return sb.toString(); } else { System.out.println("BI: Can't find configValidTime.txt file"); } } catch (Exception e) { System.out.println("BI: Read configValidTime.txt file error:" + e.getMessage()); } return defaultValue; } } /** * */ package com.companyName.dhm.common.init; import javax.servlet.ServletContext; /** * @author * */ public class SystemInitiator { static private SystemInfo systemInfo = null; static public SystemInfo getSystemInfo(){ return systemInfo; } public static void setSystemInfo(SystemInfo systemInfo) { SystemInitiator.systemInfo = systemInfo; } public static void initApp(ServletContext ctx){ //get file seperator String FS = System.getProperty("file.separator"); //get system name configed in web.xml String systemName = ctx.getInitParameter("dhm-system-name"); //get working dir String work_dir = System.getProperty("user.dir"); //set conf path String confPath = work_dir + FS + systemName+ FS + ctx.getInitParameter("system.config-path-name"); //set log path String logPath = work_dir + FS + systemName+ FS + ctx.getInitParameter("system.log-path-name"); systemInfo = new SystemInfo(systemName,confPath,logPath); System.out.println(systemInfo.toString()); } } package com.companyName.dhm.common.init; /** * @author * */ public class SystemInfo { private String systemName = null; private String confPath = null; private String logPath = null; public SystemInfo(String systemName,String confPath,String logPath) { this.systemName = systemName; this.confPath = confPath; this.logPath = logPath; } public String getSystemName() { return systemName; } public String getConfPath() { return confPath; } public String getLogPath() { return logPath; } public String toString() { return this.getClass().getName() + "[systemName=" + this.getSystemName() + ";confPath=" + this.getConfPath() + ";logPath=" + this.getLogPath() + "]"; } } /** * */ package com.companyName.dhm.common.init; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; /** * @author * */ public class VersionInfo { private static String version_info = null; /** * */ public static void init(String verFileName) { String FS = System.getProperty("file.separator"); String welcomeFile = SystemInitiator.getSystemInfo().getConfPath() + FS + verFileName; File file = new File(welcomeFile); try { FileReader fileReader = new FileReader(file); BufferedReader br = new BufferedReader(fileReader); StringBuffer sb = new StringBuffer(100); String str; boolean firstLine = true; while ((str = br.readLine()) != null) { if (firstLine) { sb.append(str); firstLine = false; } else { sb.append("\n").append(str); } } version_info = sb.toString(); br.close(); fileReader.close(); } catch (Exception e) { System.out .println("DHM: Read welcome file error:" + e.getMessage()); } } public static String getVersionInfo() { return version_info; } } /* * 工 程 名: common * 包 名: com.companyName.dhm.common.log.config * 文 件 名: Log4jConfigurer.java * 版 权: Copyright (c) 2009 companyName All Rights Reserved. * 描 述: log4j配置文件加载类 * 修 改 人: * 修改时间: * 跟踪单号: <跟踪单号> * 修改单号: <修改单号> * 修改内容: <修改内容> */ package com.companyName.dhm.common.log.config; import java.io.File; import java.io.FileNotFoundException; import java.net.MalformedURLException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import org.apache.log4j.LogManager; import org.apache.log4j.PropertyConfigurator; import org.apache.log4j.xml.DOMConfigurator; /** * * 加载log4j配置文件的接口抽象类 * 支持绝对路径，相对路径，类路径，URL等方式加载，支持log4j日志文件被修改后不用重起服务可生效 * * @author * @version * @see org.apache.log4j.xml.DOMConfigurator * @see org.apache.log4j.PropertyConfigurator * @see org.apache.log4j.LogManager * @since [DHM.Core.IEPGM-V200R001] */ public abstract class Log4jConfigurer { /** * 类路径配置的前缀 */ public static final String CLASSPATH_URL_PREFIX = "classpath:"; /** * XML日志配置文件的后缀 */ public static final String XML_FILE_EXTENSION = ".xml"; /** * 起始前缀 */ public static final String PLACEHOLDER_PREFIX = "${"; /** * 结尾后缀 */ public static final String PLACEHOLDER_SUFFIX = "}"; /** * URL标识的文件前缀 */ public static final String URL_PROTOCOL_FILE = "file"; /** * log4j.xml的路径 */ private static String log4jPath; /** * 系统启动时静态加载 log4j配置文件 * @param location 加载log4j配置文件的路径 * @exception throws [FileNotFoundException ] [文件未被找到] */ public static void initLogging(String location) throws FileNotFoundException { // 设置log4j的绝对路径 log4jPath = location; String resolvedLocation = resolvePlaceholders(location); URL url = getURL(resolvedLocation); if (resolvedLocation.toLowerCase().endsWith(XML_FILE_EXTENSION)) { DOMConfigurator.configure(url); } else { PropertyConfigurator.configure(url); } } /** * 当log4j配置文件发生改变时会重新加载 * @param location 加载log4j配置文件的路径 * @param refreshInterval 间隔刷新时间 * @exception throws [FileNotFoundException ] [文件未被找到] */ public static void initLogging(String location,long refreshInterval) throws FileNotFoundException { // 设置log4j的绝对路径 log4jPath = location; String resolvedLocation = resolvePlaceholders(location); File file = getFile(resolvedLocation); if (!file.exists()) { throw new FileNotFoundException("Log4j config file [" + resolvedLocation + "] not found"); } if (resolvedLocation.toLowerCase().endsWith(XML_FILE_EXTENSION)) { DOMConfigurator.configureAndWatch(file.getAbsolutePath(),refreshInterval); } else { PropertyConfigurator.configureAndWatch(file.getAbsolutePath(),refreshInterval); } } /** * 关闭日志记录器 */ public static void shutdownLogging() { LogManager.shutdown(); } /** * 设置系统的工作目录 * @param key * system property key to use,as expected in Log4j configuration * (for example: "demo.root",used as * "${demo.root}/WEB-INF/demo.log") */ public static void setWorkingDirSystemProperty(String key) { System.setProperty(key,new File("").getAbsolutePath()); } /** * 替换${}，得到真实的路径参数 * @param text 要替换的文本 * @return String [替换后的文本] */ public static String resolvePlaceholders(String text) { StringBuffer buf = new StringBuffer(text); String placeholder = null; int nextIndex = 0; String propVal = null; int startIndex = buf.indexOf(PLACEHOLDER_PREFIX); while (startIndex != -1) { int endIndex = buf.indexOf(PLACEHOLDER_SUFFIX,startIndex + PLACEHOLDER_PREFIX.length()); if (endIndex != -1) { placeholder = buf.substring(startIndex + PLACEHOLDER_PREFIX.length(),endIndex); nextIndex = endIndex + PLACEHOLDER_SUFFIX.length(); try { propVal = System.getProperty(placeholder); if (propVal == null) { // Fall back to searching the system environment. propVal = System.getenv(placeholder); } if (propVal != null) { buf.replace(startIndex,endIndex + PLACEHOLDER_SUFFIX.length(),propVal); nextIndex = startIndex + propVal.length(); } else { System.err.println("Could not resolve placeholder '" + placeholder + "' in [" + text + "] as system property: neither system property nor environment variable found"); } } catch (Throwable ex) { System.err.println("Could not resolve placeholder '" + placeholder + "' in [" + text + "] as system property: " + ex); } startIndex = buf.indexOf(PLACEHOLDER_PREFIX,nextIndex); } else { startIndex = -1; } } return buf.toString(); } /** * 根据文件的上下文路径获得URL对象 * 可以通过类路径,URL,绝对路径，相对路径来获得 * @param resourceLocation 文件的上下文路径 * @return URL [URL对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static URL getURL(String resourceLocation) throws FileNotFoundException { if (null == resourceLocation) { throw new IllegalArgumentException( "Resource location must not be null"); } // 通过类路径classpath加载log4j得到路径 if (resourceLocation.startsWith(CLASSPATH_URL_PREFIX)) { // 得到类的相对路径 String path = resourceLocation.substring(CLASSPATH_URL_PREFIX.length()); URL url = getDefaultClassLoader().getResource(path); if (url == null) { String description = "class path resource [" + path + "]"; throw new FileNotFoundException( description + " cannot be resolved to URL because it does not exist"); } return url; } try { // 直接通过相对加载 return new URL(resourceLocation); } catch (MalformedURLException ex) { // no URL -> treat as file path try { // 通过文件路径加载 return new File(resourceLocation).toURI().toURL(); } catch (MalformedURLException ex2) { throw new FileNotFoundException("Resource location [" + resourceLocation + "] is neither a URL not a well-formed file path"); } } } /** * 根据文件的上下文路径获得文件对象 * 可以通过类路径,绝对路径，相对路径来获得 * @param resourceLocation 文件的上下文路径 * @return File [文件对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static File getFile(String resourceLocation) throws FileNotFoundException { if (null == resourceLocation) { throw new IllegalArgumentException( "Resource location must not be null"); } // 通过类路径 if (resourceLocation.startsWith(CLASSPATH_URL_PREFIX)) { String path = resourceLocation.substring(CLASSPATH_URL_PREFIX.length()); String description = "class path resource [" + path + "]"; URL url = getDefaultClassLoader().getResource(path); if (url == null) { throw new FileNotFoundException(description + " cannot be resolved to absolute file path " + "because it does not reside in the file system"); } return getFile(url,description); } try { // try URL return getFile(new URL(resourceLocation)); } catch (MalformedURLException ex) { // no URL -> treat as file path return new File(resourceLocation); } } /** * 根据URL获得具体的文件 * @param resourceUrl 文件的URL路径 * @return File [文件对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static File getFile(URL resourceUrl) throws FileNotFoundException { return getFile(resourceUrl,"URL"); } /** * 根据URL获得具体的文件 * @param resourceUrl 文件的URL路径 * @param description 文件描述 * @return File [文件对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static File getFile(URL resourceUrl,String description) throws FileNotFoundException { // Assert.notNull(resourceUrl,"Resource URL must not be null"); if (null == resourceUrl) { throw new IllegalArgumentException("Resource URL must not be null"); } if (!URL_PROTOCOL_FILE.equals(resourceUrl.getProtocol())) { throw new FileNotFoundException(description + " cannot be resolved to absolute file path " + "because it does not reside in the file system: " + resourceUrl); } try { return new File(toURI(resourceUrl).getSchemeSpecificPart()); } catch (URISyntaxException ex) { // Fallback for URLs that are not valid URIs (should hardly ever // happen). return new File(resourceUrl.getFile()); } } /** * 根据URI获得具体的文件 * @param resourceUri 文件的URI路径 * @return File [文件对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static File getFile(URI resourceUri) throws FileNotFoundException { return getFile(resourceUri,"URI"); } /** * 根据URI获得具体的文件 * @param resourceUri 文件的URI路径 * @param description 文件描述 * @return File [文件对象] * @exception throws [FileNotFoundException] [文件没有被找到异常] */ public static File getFile(URI resourceUri,String description) throws FileNotFoundException { // Assert.notNull(resourceUri,"Resource URI must not be null"); if (null == resourceUri) { throw new IllegalArgumentException("Resource URI must not be null"); } if (!URL_PROTOCOL_FILE.equals(resourceUri.getScheme())) { throw new FileNotFoundException(description + " cannot be resolved to absolute file path " + "because it does not reside in the file system: " + resourceUri); } return new File(resourceUri.getSchemeSpecificPart()); } /** * 将URL转换成URI对象 * @param url url对象 * @return URI [URI对象] * @exception throws [URISyntaxException ] [URI转换异常] */ public static URI toURI(URL url) throws URISyntaxException { return toURI(url.toString()); } /** * 根据文件路径获得URI对象 * @param location 文件路径 * @return URI [URI路径] * @exception throws [URISyntaxException] [URI转换异常] */ public static URI toURI(String location) throws URISyntaxException { // 进行路径中的空格替换 return new URI(replace(location," ","%20")); } /** * 获得类装载器 * @return ClassLoader [类装载器] */ public static ClassLoader getDefaultClassLoader() { ClassLoader cl = null; try { cl = Thread.currentThread().getContextClassLoader(); } catch (Throwable ex) { // Cannot access thread context ClassLoader - falling back to system // class loader... } if (cl == null) { // No thread context class loader -> use class loader of this class. cl = Log4jConfigurer.class.getClassLoader(); } return cl; } /** * 字符串替换 * @param inString 要替换的字符串 * @param oldPattern 替换前的字符 * @param newPattern 替换后的字符 * @return String [替换后的字符串] */ public static String replace(String inString,String oldPattern,String newPattern) { if (!hasLength(inString) || !hasLength(oldPattern) || newPattern == null) { return inString; } StringBuffer sbuf = new StringBuffer(); // output StringBuffer we'll build up int pos = 0; // our position in the old string int index = inString.indexOf(oldPattern); // the index of an occurrence we've found,or -1 int patLen = oldPattern.length(); while (index >= 0) { sbuf.append(inString.substring(pos,index)); sbuf.append(newPattern); pos = index + patLen; index = inString.indexOf(oldPattern,pos); } sbuf.append(inString.substring(pos)); // remember to append any characters to the right of a match return sbuf.toString(); } /** * 判断字符串是否有长度 * @param str 字符串String * @return boolean [true-有 false-没有] */ public static boolean hasLength(String str) { return hasLength((CharSequence) str); } /** * 判断字符串是否有长度 * @param str CharSequence字符序列 * @return boolean [true-有 false-没有] */ public static boolean hasLength(CharSequence str) { return (str != null && str.length() > 0); } /** * @return 返回 log4jPath */ public static String getLog4jPath() { return log4jPath; } public static void main(String[] args) { System.out.println(getRootPath("D:/aaaa////////////tree.txt/aaa",true)); } public static String getRootPath(String curretpath,boolean isFile) { if (null == curretpath || "".equals(curretpath)) { return curretpath; } File f = new File(curretpath); curretpath = f.getPath(); int tmp = 0; StringBuffer buf = new StringBuffer(); while ((tmp = curretpath.indexOf(File.separator,tmp)) != -1) { tmp++; if (isFile) { isFile = false; continue; } buf.append("..").append("/"); } return buf.toString(); } } package com.companyName.dhm.common.config.impl; import java.util.List; import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.XMLConfiguration; import org.apache.log4j.Logger; import com.companyName.dhm.common.config.base.DataBaseConfig; /** * ConfigFactory.java * <p>Copyright: Copyright (c) 2009 <p> * <p>Company: companyName</p> * @author * @version 1.0 */ public class ConfigFactory { private static Logger log = Logger.getLogger(ConfigFactory.class); public ConfigFactory() { } /** * 初始化配置 * @param path:sysConfig.xml的路径 */ public void initConfig(String confPath,String file) { String FS = System.getProperty("file.separator"); if (file == null) { log.error("配置文件SysConfig.xml路径地址尚未初始化,请查看web.xml文件"); return; } XMLConfiguration config = null; try { config = new XMLConfiguration(confPath + FS + file); } catch (ConfigurationException e) { log.error("加载配置文件 SysConfig.xml 发生错误，请查看文件是否存在，或格式是否错误"); return; } List<String> proList = config.getList("properties.filepath"); for (String pPath : proList) { pPath = confPath + FS + pPath; log.debug("开始加载配置文件 path:" + pPath); PropertiesFactory.addConfiguration(pPath); } List<String> xmlList = config.getList("xml.filepath"); for (String xPath : xmlList) { xPath = confPath + FS + xPath; log.debug("开始加载配置文件 path:" + xPath); XMLFactory.addConfiguration(xPath); } if (config.getString("data.dataConn.driverName") != null && config.getString("data.dataConn.jdbcUrl") != null && config.getString("data.dataConn.userName") != null && config.getString("data.dataConn.passWd") != null && config.getString("data.table.tableName") != null && config.getString("data.table.key") != null && config.getString("data.table.value") != null) { log.debug("开始加载数据库配置信息"); //初始化参数 DataFactory.setParameters(config.getString("data.dataConn.driverName"),config.getString("data.dataConn.jdbcUrl"),config .getString("data.dataConn.userName"),config .getString("data.dataConn.passWd"),config .getString("data.table.tableName"),config .getString("data.table.type"),config .getString("data.table.key"),config .getString("data.table.value")); } } } package com.companyName.dhm.common.config.impl; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Iterator; import java.util.List; import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.XMLConfiguration; import org.apache.log4j.Logger; import com.companyName.dhm.common.config.base.CompositeConfig; import com.companyName.dhm.common.util.StringUtil; /** * XMLFactory.java * <p>Copyright: Copyright (c) 2009 <p> * <p>Company: companyName</p> * @author * @version 1.0 */ public class XMLFactory { private static Logger log = Logger.getLogger(XMLFactory.class); private final static CompositeConfig config = new CompositeConfig(); private static boolean initFlag = false; private XMLFactory() { } /** * 增加新的配置文件信息 * @param path 配置文件地址 */ public synchronized static void addConfiguration(String path) { initFlag = true; try { XMLConfiguration configuration= new XMLConfiguration(path); configuration.setEncoding("UTF-8"); config.addConfiguration(configuration); } catch (ConfigurationException e) { log.error("加载配置文件 " + path + " 发生错误，请查看文件是否存在，或格式是否错误"); } } /** * 获取长整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static long getValueLong(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getLong(key); } /** * * 获取迭代器 * * @param key 取得其值的键 * @return key的值 */ public static Iterator getKeys() { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getKeys(); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static int getValueInt(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getInt(key); } /** * * 获取数组类型的值 * * @param key 取得其值的键 * @return key的值 */ public static String[] getValueArray(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getStringArray(key); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @return key的值 */ public static String getValueString(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getString(key); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @param params 替换的参数,例如{"1","22","33"} * @return key的值 */ public static String getValueString(String key,String[] params) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return StringUtil.substituteParams(config.getString(key),params); } /** * * 获取双精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static double getValueDouble(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getDouble(key); } /** * 获取高精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static BigDecimal getValueBigDecimal(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBigDecimal(key); } /** * 获取浮点数字类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static float getValueFloat(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getFloat(key); } /** * 获取布尔类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static boolean getValueBoolean(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBoolean(key); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static BigInteger getValueBigInteger(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBigInteger(key); } /** * 获取List类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static List getValueList(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getList(key); } /** * 清除配置文件中所有的key和其值 */ public static void clear() { if (config != null) { config.clear(); initFlag = false; } } /** * 保存相应的值,该值存在进行修改，不存在不处理 * @param key 需要保存的KEY * @param value 需要保存的值 */ public static void setProperty(String key,String value){ if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } config.setPropertyXML(key,value); } } package com.companyName.dhm.common.config.base; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import org.apache.commons.configuration.*; import org.apache.log4j.Logger; /** * CompositeConfig.java * <p>Copyright: Copyright (c) 2009<p> * <p>Company: companyName</p> * @author * @version 1.0 */ public class CompositeConfig extends AbstractConfiguration implements Cloneable { private static Logger logger = Logger.getLogger(CompositeConfig.class); /** 配置列表 */ private List configList = new LinkedList(); /** * 保存配置的对象. 第一次调用新增方法时override父类的新增 */ private Configuration inMemoryConfiguration; /** * 构造函数 */ public CompositeConfig() { clear(); } /** * 新增配置项资源文件 * * @param config * the configuration to add */ public void addConfiguration(Configuration config) { if (!configList.contains(config)) { // As the inMemoryConfiguration contains all manually added keys,// we must make sure that it is always last. "Normal",non composed // configuration add their keys at the end of the configuration and // we want to mimic this behavIoUr. configList.add(configList.indexOf(inMemoryConfiguration),config); if (config instanceof AbstractConfiguration) { ((AbstractConfiguration) config) .setThrowExceptionOnMissing(isThrowExceptionOnMissing()); } } } /** * 删除配置项 * @param config */ public void removeConfiguration(Configuration config) { // Make sure that you can't remove the inMemoryConfiguration from // the CompositeConfiguration object if (!config.equals(inMemoryConfiguration)) { configList.remove(config); } } /** * 获取当前加载的配置数量 * * @return the number of configuration */ public int getNumberOfConfigurations() { return configList.size(); } /** * 清空所有已加载到内存中的配置信息 */ public void clear() { configList.clear(); // recreate the in memory configuration inMemoryConfiguration = new BaseConfiguration(); ((BaseConfiguration) inMemoryConfiguration) .setThrowExceptionOnMissing(isThrowExceptionOnMissing()); ((BaseConfiguration) inMemoryConfiguration).setListDelimiter(getListDelimiter()); ((BaseConfiguration) inMemoryConfiguration) .setDelimiterParsingDisabled(isDelimiterParsingDisabled()); configList.add(inMemoryConfiguration); } /** * 增加新的配置项 * * @param key * @param token */ protected void addPropertyDirect(String key,Object token) { inMemoryConfiguration.addProperty(key,token); } /** * 增加新的配置项,仅支持XML格式 * * @param key * @param token */ public void setPropertyXML(String key,Object obj) { for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); if (config.containsKey(key)) { ((XMLConfiguration) config).setProperty(key,obj); try { ((XMLConfiguration) config).save(); } catch (ConfigurationException e) { logger.error("更新配置项 key:" + key + ";value:" + obj + " 失败"); } } } } /** * 增加新的配置项,仅支持Properties格式 * * @param key * @param token */ public void setPropertyProperties(String key,Object obj) { for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); if (config.containsKey(key)) { ((PropertiesConfiguration) config).setProperty(key,obj); try { ((PropertiesConfiguration) config).save(); } catch (ConfigurationException e) { logger.error("更新配置项 key:" + key + ";value:" + obj + " 失败"); } } } } /** * 获取key对应的value * * @param key * @return value */ public Object getProperty(String key) { Configuration firstMatchingConfiguration = null; for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); if (config.containsKey(key)) { firstMatchingConfiguration = config; break; } } if (firstMatchingConfiguration != null) { return firstMatchingConfiguration.getProperty(key); } else { return null; } } /** * 获取key对应的迭代器 * @return Iterator */ public Iterator getKeys() { List keys = new ArrayList(); for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); Iterator j = config.getKeys(); while (j.hasNext()) { String key = (String) j.next(); if (!keys.contains(key)) { keys.add(key); } } } return keys.iterator(); } /** * 获取key对应的迭代器 * @param key * @return Iterator */ public Iterator getKeys(String key) { List keys = new ArrayList(); for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); Iterator j = config.getKeys(key); while (j.hasNext()) { String newKey = (String) j.next(); if (!keys.contains(newKey)) { keys.add(newKey); } } } return keys.iterator(); } /** * 校验列表是否为空 * @param key * @return boolean */ public boolean isEmpty() { boolean isEmpty = true; for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); if (!config.isEmpty()) { return false; } } return isEmpty; } protected void clearPropertyDirect(String key) { for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); config.clearProperty(key); } } public boolean containsKey(String key) { for (Iterator i = configList.iterator(); i.hasNext();) { Configuration config = (Configuration) i.next(); if (config.containsKey(key)) { return true; } } return false; } public List getList(String key,List defaultValue) { List list = new ArrayList(); // add all elements from the first configuration containing the requested key Iterator it = configList.iterator(); while (it.hasNext() && list.isEmpty()) { Configuration config = (Configuration) it.next(); if (config != inMemoryConfiguration && config.containsKey(key)) { appendListProperty(list,config,key); } } // add all elements from the in memory configuration appendListProperty(list,inMemoryConfiguration,key); if (list.isEmpty()) { return defaultValue; } ListIterator lit = list.listIterator(); while (lit.hasNext()) { lit.set(interpolate(lit.next())); } return list; } public String[] getStringArray(String key) { List list = getList(key); // transform property values into strings String[] tokens = new String[list.size()]; for (int i = 0; i < tokens.length; i++) { tokens[i] = String.valueOf(list.get(i)); } return tokens; } /** * Return the configuration at the specified index. * * @param index * The index of the configuration to retrieve * @return the configuration at this index */ public Configuration getConfiguration(int index) { return (Configuration) configList.get(index); } /** * Returns the &quot;in memory configuration&quot;. In this configuration changes are * stored. * * @return the in memory configuration */ public Configuration getInMemoryConfiguration() { return inMemoryConfiguration; } /** * Returns a copy of this object. This implementation will create a deep clone,i.e. * all configurations contained in this composite will also be cloned. This only works * if all contained configurations support cloning; otherwise a runtime exception will * be thrown. Registered event handlers won't get cloned. * * @return the copy * @since 1.3 */ public Object clone() { try { CompositeConfig copy = (CompositeConfig) super.clone(); copy.clearConfigurationListeners(); copy.configList = new LinkedList(); copy.inMemoryConfiguration = ConfigurationUtils .cloneConfiguration(getInMemoryConfiguration()); copy.configList.add(copy.inMemoryConfiguration); for (int i = 0; i < getNumberOfConfigurations(); i++) { Configuration config = getConfiguration(i); if (config != getInMemoryConfiguration()) { copy.addConfiguration(ConfigurationUtils.cloneConfiguration(config)); } } return copy; } catch (CloneNotSupportedException cnex) { // cannot happen throw new ConfigurationRuntimeException(cnex); } } /** * Sets a flag whether added values for string properties should be checked for the * list delimiter. This implementation ensures that the in memory configuration is * correctly initialized. * * @param delimiterParsingDisabled * the new value of the flag * @since 1.4 */ public void setDelimiterParsingDisabled(boolean delimiterParsingDisabled) { ((BaseConfiguration) getInMemoryConfiguration()) .setDelimiterParsingDisabled(delimiterParsingDisabled); super.setDelimiterParsingDisabled(delimiterParsingDisabled); } /** * Sets the character that is used as list delimiter. This implementation ensures that * the in memory configuration is correctly initialized. * * @param listDelimiter * the new list delimiter character * @since 1.4 */ public void setListDelimiter(char listDelimiter) { ((BaseConfiguration) getInMemoryConfiguration()).setListDelimiter(listDelimiter); super.setListDelimiter(listDelimiter); } /** * Returns the configuration source,in which the specified key is defined. This * method will iterate over all existing child configurations and check whether they * contain the specified key. The following constellations are possible: * <ul> * <li>If exactly one child configuration contains the key,this configuration is * returned as the source configuration. This may be the * <em>in memory configuration</em> (this has to be explicitly checked by the * calling application).</li> * <li>If none of the child configurations contain the key,<b>null</b> is returned.</li> * <li>If the key is contained in multiple child configurations or if the key is * <b>null</b>,a <code>IllegalArgumentException</code> is thrown. In this case the * source configuration cannot be determined.</li> * </ul> * * @param key * the key to be checked * @return the source configuration of this key * @throws IllegalArgumentException * if the source configuration cannot be determined * @since 1.5 */ public Configuration getSource(String key) { if (key == null) { throw new IllegalArgumentException("Key must not be null!"); } Configuration source = null; for (Iterator it = configList.iterator(); it.hasNext();) { Configuration conf = (Configuration) it.next(); if (conf.containsKey(key)) { if (source != null) { throw new IllegalArgumentException("The key " + key + " is defined by multiple sources!"); } source = conf; } } return source; } /** * Adds the value of a property to the given list. This method is used by * <code>getList()</code> for gathering property values from the child * configurations. * * @param dest * the list for collecting the data * @param config * the configuration to query * @param key * the key of the property */ private static void appendListProperty(List dest,Configuration config,String key) { Object value = config.getProperty(key); if (value != null) { if (value instanceof Collection) { dest.addAll((Collection) value); } else { dest.add(value); } } } } package com.companyName.dhm.common.util; import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.HashMap; import java.util.List; import net.sf.json.JSONArray; import com.google.gson.Gson; public class StringUtil { public static String substituteParams(String msgtext,Object params[]) { if (params == null || msgtext == null) { return msgtext; } MessageFormat mf = new MessageFormat(msgtext); return mf.format(params); } //private static final String S_FORMAT_DATETIME = "%1$tF %1$tT"; private static final String S_FORMAT_DATE = "%1$tF"; private static final String SDF_FORMAT_DATE = "yyyy-MM-dd"; private static final String SDF_FORMAT_MONTH = "yyyy-MM"; /** * 上周的年份 * @return */ public static int year() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DAY_OF_YEAR,-7); return calendar.get(java.util.Calendar.YEAR); } /** * 上周 * @return */ public static int week() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DAY_OF_YEAR,-7); return calendar.get(java.util.Calendar.WEEK_OF_YEAR); } /** * 前天 * @return */ public static String startDate() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DAY_OF_YEAR,-2); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 昨天 * @return */ public static String endDate() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DAY_OF_YEAR,-1); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 获取昨天 * @return */ public static String beforeDay() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DAY_OF_YEAR,-1); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 获取上周一 * @return */ public static String beforeWeek() { Calendar calendar = Calendar.getInstance(); int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1; dayOfWeek = 1 - dayOfWeek; // 从周一开始 calendar.add(Calendar.DATE,dayOfWeek - 7); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 获取前月 * @return */ public static String beforeMonth() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.MONTH,-1); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_MONTH); return sdf.format(calendar.getTime()); } /** * 上上周一 * @return */ public static String startWeek() { Calendar calendar = Calendar.getInstance(); int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1; dayOfWeek = 1 - dayOfWeek; // 从周一开始 calendar.add(Calendar.DATE,dayOfWeek - 14); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 上周日 * @return */ public static String endWeek() { Calendar calendar = Calendar.getInstance(); int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1; dayOfWeek = 1 - dayOfWeek; // 从周一开始 calendar.add(Calendar.DATE,dayOfWeek - 1); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_DATE); return sdf.format(calendar.getTime()); } /** * 前月 * @return */ public static String startMonth() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.MONTH,-2); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_MONTH); return sdf.format(calendar.getTime()); } /** * 上月 * @return */ public static String endMonth() { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.MONTH,-1); SimpleDateFormat sdf = new SimpleDateFormat(SDF_FORMAT_MONTH); return sdf.format(calendar.getTime()); } /** * 周的树形数据 * @return */ public static String weekTree() { List<HashMap<String,String>> weeks = new ArrayList<HashMap<String,String>>(); String rootCode = ""; HashMap<String,String> map = new HashMap<String,String>(); map.put("areaName","全选/反选"); map.put("areaCode",rootCode); weeks.add(map); for (int i = 1; i <= 53; i++) { map = new HashMap<String,String>(); map.put("areaName","第" + i + "周"); map.put("areaCode",String.valueOf(i)); map.put("serviceAreaCode",rootCode); weeks.add(map); } Gson gson = new Gson(); //System.out.println("weekTree: " + gson.toJson(weeks)); return gson.toJson(weeks); } /** * 初始化25周数据 * @return */ public static String weeks() { List<HashMap<String,String>>(); HashMap<String,String>(); Calendar calendar = new GregorianCalendar(); calendar.setFirstDayOfWeek(Calendar.MONDAY); calendar.setTime(new Date()); calendar.set(Calendar.DAY_OF_WEEK,calendar.getFirstDayOfWeek()); // Monday for (int w = 0; w < 26; w++) { calendar.add(Calendar.DATE,-1); String weDate = String.format(S_FORMAT_DATE,calendar.getTime()); calendar.add(Calendar.DATE,-6); String wsDate = String.format(S_FORMAT_DATE,calendar.getTime()); map = new HashMap<String,String>(); map.put("value",wsDate); map.put("text","第" + calendar.get(Calendar.WEEK_OF_YEAR) + "周(" + wsDate + "至" + weDate + ")"); weeks.add(map); } return JSONArray.fromObject(weeks).toString(); } /** * 保留浮点数小数位数 * @param d 数值 * @param len 小数位数 * @return */ public static String doubleFormat(double d,int len) { BigDecimal b = new BigDecimal(Double.toString(d)); return decFormat(b,len); } public static String decFormat(BigDecimal d,int len) { DecimalFormat df = new DecimalFormat("0.0000000000000"); String result = df.format(d); int index = result.indexOf(".") + 1; // 索引从1开始 result = result.substring(0,index + len); // 保留3位小数点 return result; } } package com.companyName.dhm.common.util; import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.HashMap; import java.util.List; import net.sf.json.JSONArray; import com.google.gson.Gson; public class StringUtil { public static String substituteParams(String msgtext,index + len); // 保留3位小数点 return result; } } package com.companyName.dhm.common.config.impl; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Iterator; import java.util.List; import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.PropertiesConfiguration; import org.apache.commons.configuration.XMLConfiguration; import org.apache.log4j.Logger; import com.companyName.dhm.common.config.base.CompositeConfig; import com.companyName.dhm.common.util.StringUtil; /** * PropertiesFactory.java * <p>Copyright: Copyright (c) 2009 <p> * <p>Company: companyName</p> * @author 903677 * @version 1.0 */ public class PropertiesFactory { private static Logger log = Logger.getLogger(PropertiesFactory.class); private final static CompositeConfig config = new CompositeConfig(); private static boolean initFlag = false; private PropertiesFactory() { } /** * 增加新的配置文件信息 * @param path 配置文件地址 */ public synchronized static void addConfiguration(String path) { initFlag = true; try { PropertiesConfiguration configuration= new PropertiesConfiguration(path); configuration.setEncoding("UTF-8"); config.addConfiguration(configuration); } catch (ConfigurationException e) { log.error("加载配置文件 " + path + " 发生错误，请查看文件是否存在，或格式是否错误"); } } /** * 获取长整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static long getValueLong(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getLong(key); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static int getValueInt(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getInt(key); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @return key的值 */ public static String getValueString(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getString(key); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @param params 替换的参数,params); } /** * * 获取双精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static double getValueDouble(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getDouble(key); } /** * * 获取迭代器 * * @param key 取得其值的键 * @return key的值 */ public static Iterator getKeys() { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getKeys(); } /** * * 获取数组类型的值 * * @param key 取得其值的键 * @return key的值 */ public static String[] getValueArray(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getStringArray(key); } /** * 获取高精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static BigDecimal getValueBigDecimal(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBigDecimal(key); } /** * 获取浮点数字类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static float getValueFloat(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getFloat(key); } /** * 获取布尔类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static boolean getValueBoolean(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBoolean(key); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static BigInteger getValueBigInteger(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getBigInteger(key); } /** * 获取List类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static List getValueList(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getList(key); } /** * 清除配置文件中所有的key和其值 */ public static void clear() { if (config != null) { config.clear(); initFlag = false; } } /** * 保存相应的值,String value) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } config.setPropertyProperties(key,value); } } package com.companyName.dhm.common.config.impl; import java.math.BigDecimal; import java.math.BigInteger; import java.util.ArrayList; import java.util.List; import org.apache.commons.configuration.PropertyConverter; import org.apache.log4j.Logger; import com.companyName.dhm.common.config.base.DataBaseConfig; import com.companyName.dhm.common.util.StringUtil; /** * DataFactory.java * <p>Copyright: Copyright (c) 2009 <p> * <p>Company: companyName</p> * @author 903677 * @version 1.0 */ public class DataFactory { private static Logger log = Logger.getLogger(DataFactory.class); private final static DataBaseConfig config = new DataBaseConfig(); private static boolean initFlag = false; private DataFactory() { } /** * 设置数据库相应参数 * @param sDriver_Name 数据库驱名 * @param jdbc_url 数据库URL * @param userName 数据库登录用户名 * @param passwd 数据库登录密码 * @param table 配置表表名 * @param typeColumn 配置表类型字段 * @param keyColumn 配置表KEY字段 * @param valueColumn 配置表VALUE字段 */ public static void setParameters(String sDriver_Name,String jdbc_url,String userName,String passwd,String table,String typeColumn,String keyColumn,String valueColumn) { initFlag = true; config.setParameters(sDriver_Name,jdbc_url,userName,passwd,table,typeColumn,keyColumn,valueColumn); } /** * 获取长整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static long getValueLong(String key) { return getValueLong(key,null); } /** * 获取长整型类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key的值 */ public static long getValueLong(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return Long.parseLong(config.getProperty(key,type)); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key的值 */ public static int getValueInt(String key) { return getValueInt(key,null); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key的值 */ public static int getValueInt(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return Integer.parseInt(config.getProperty(key,type)); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @return key的值 */ public static String getValueString(String key) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getProperty(key,null); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key的值 */ public static String getValueString(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return config.getProperty(key,type); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @param params 替换的参数,String type,String[] params) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return StringUtil.substituteParams(config.getProperty(key,type),params); } /** * 获取字符串类型的值 * * @param key 取得其值的键 * @param params 替换的参数,String[] params) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return StringUtil.substituteParams(config.getProperty(key),params); } /** * 获取双精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static double getValueDouble(String key) { return getValueDouble(key,null); } /** * * 获取双精度数字类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key的值 */ public static double getValueDouble(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return Double.parseDouble(config.getProperty(key,type)); } /** * 获取高精度数字类型的值 * * @param key 取得其值的键 * @return key的值 */ public static BigDecimal getValueBigDecimal(String key) { return getValueBigDecimal(key,null); } /** * 获取高精度数字类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key的值 */ public static BigDecimal getValueBigDecimal(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return PropertyConverter.toBigDecimal(config.getProperty(key,type)); } /** * 获取浮点数字类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static float getValueFloat(String key) { return getValueFloat(key,null); } /** * 获取浮点数字类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key对应的Value */ public static float getValueFloat(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return Float.parseFloat(config.getProperty(key,type)); } /** * 获取布尔类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static boolean getValueBoolean(String key) { return getValueBoolean(key,null); } /** * 获取布尔类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key对应的Value */ public static boolean getValueBoolean(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return Boolean.parseBoolean(config.getProperty(key,type)); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static BigInteger getValueBigInteger(String key) { return getValueBigInteger(key,null); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key对应的Value */ public static BigInteger getValueBigInteger(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } return PropertyConverter.toBigInteger(config.getProperty(key,type)); } /** * 获取List类型的值 * * @param key 取得其值的键 * @return key对应的Value */ public static List getValueList(String key) { return getValueList(key,null); } /** * 获取整型类型的值 * * @param key 取得其值的键 * @param type 所取值的类型 * @return key对应的Value */ public static List getValueList(String key,String type) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); } List list = new ArrayList(); list.add(config.getProperty(key,type)); return list; } /** * 保存相应的值,该值存在进行修改，不存在，进行新增 * * @param key 需要保存的KEY * @param value 需要保存的值 */ public static void setProperty(String key,String value) { setProperty(key,null,value); } /** * 保存相应的值,该值存在进行修改，不存在，进行新增 * * @param key 需要保存的KEY * @param type 所取值的类型 * @param value 需要保存的值 */ public static void setProperty(String key,String value) { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); return; } config.addProperty(key,type,value); } /** * 刷新该资源配置 */ public static void reSet() { if (!initFlag) { log.error("资源配置尚未初始化，或者资源文件不存在"); return; } config.reSet(); } } package com.companyName.dhm.common.config.base; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.sqlException; import java.sql.Statement; import java.util.Hashtable; import java.util.Iterator; import org.apache.commons.configuration.AbstractConfiguration; import org.apache.log4j.Logger; /** * DataBaseConfig.java * <p>Copyright: Copyright (c) 2009 <p> * <p>Company: companyName</p> * @author 903677 * @version 1.0 */ public class DataBaseConfig extends AbstractConfiguration { private static Logger logger = Logger.getLogger(DataBaseConfig.class); /** * 用户存放数据库相关信息 */ private String DB_PARAM[] = { "driverName","jdbcUrl","userName","passWd" }; /** * 配置表表名 */ private String table; /** * 配置表类型字段 */ private String typeColumn; /** * 配置表KEY字段 */ private String keyColumn; /** * 配置表VALUE字段 */ private String valueColumn; /** * 用于存放配置项的集合 */ private Hashtable<String,String> tab = null; /** * @param sDriver_Name 数据库驱名 * @param jdbc_url 数据库URL * @param userName 数据库登录用户名 * @param passwd 数据库登录密码 * @param table 配置表表名 * @param typeColumn 配置表类型字段 * @param keyColumn 配置表KEY字段 * @param valueColumn 配置表VALUE字段 */ public void setParameters(String sDriver_Name,String valueColumn) { this.DB_PARAM[0] = sDriver_Name; this.DB_PARAM[1] = jdbc_url; this.DB_PARAM[2] = userName; this.DB_PARAM[3] = passwd; this.table = table; this.typeColumn = typeColumn; this.keyColumn = keyColumn; this.valueColumn = valueColumn; readConfig(); } /** * 根据key获取相应的value * @param key * @return key对应的value */ public String getProperty(String key) { return this.getProperty(key,null); } /** * 根据key，type获取相应的value * @param key * @param type * @return 相应的key与type对应的value */ public String getProperty(String key,String type) { if (tab == null) { logger.error("数据库资源信息尚未初始化"); return null; } if (this.typeColumn == null) { return tab.get(key); } else { return tab.get(type + "|" + key); } } /** * @return */ public boolean isEmpty() { return tab == null; } /** * @param key * @return 该key在配置中是否存在,存在返回true,不存在返回false */ public boolean containsKey(String key) { return this.containsKey(key,null); } /** * @param key * @param type * @return 该key在配置中对应的type类型中是否存在,不存在返回false */ public boolean containsKey(String key,String type) { if (tab == null) { return false; } if (this.typeColumn == null) { return tab.containsKey(key); } else { return tab.containsKey(type + "|" + key); } } /** * 清除缓存中的数据 */ public void reSet() { clear(); readConfig(); } /** * 清除缓存中的数据 */ public void clear() { if (tab != null) { tab.clear(); tab = null; } } /** * @return */ public Iterator getKeys() { return null; } @Override protected void addPropertyDirect(String arg0,Object arg1) { } /** * 保存相应的值,该值存在进行修改，不存在，进行新增 * * @param key 需要保存的KEY * @param value 需要保存的值 */ public void addProperty(String key,String value) { addProperty(key,该值存在进行修改，不存在，进行新增 * * @param key 需要保存的KEY * @param type 需要保存的KEY对应的类型 * @param value 需要保存的值 */ public synchronized void addProperty(String key,String value) { if (tab == null) { logger.error("修改配置失败:资源配置尚未初始化!"); return; } // 重新获取配置，已防缓存中的配置陈旧 reSet(); if (this.typeColumn == null) { if (tab.containsKey(key)) { updateProperty(key,value); } else { insertProperty(key,value); } } else { if (type == null) { logger.error("修改配置失败:在key与type为联合主键的模式下type不能为空"); return; } if (tab.containsKey(type + "|" + key)) { updateProperty(key,value); } } } /** * 将新增配置项添加到数据库中 * @param key 需要保存的KEY * @param type 需要保存的KEY对应的类型 * @param value 需要保存的值 */ private void insertProperty(String key,String value) { StringBuffer query = new StringBuffer("INSERT INTO " + this.table); if (this.typeColumn != null) { query.append(" (" + this.typeColumn + "," + this.keyColumn + "," + this.valueColumn + ") VALUES (?,?,?)"); } else { query.append(" (" + this.keyColumn + "," + this.valueColumn + ") VALUES (?,?)"); } Connection conn = null; PreparedStatement pstmt = null; try { conn = getConnection(); logger.debug(" insertProperty query :" + query.toString()); pstmt = conn.prepareStatement(query.toString()); int index = 1; if (this.typeColumn != null) { pstmt.setString(index++,type); } pstmt.setString(index++,key); pstmt.setString(index++,value); // 将新增项加入到数据库中 pstmt.executeUpdate(); // 将新增项加入到缓存中 if (this.typeColumn == null) { tab.put(key,value); } else { tab.put(type + "|" + key,value); } } catch (sqlException e) { logger.error("新增配置失败:key:" + key + ";type:" + type + ";value:" + value); } finally { close(conn,pstmt,null); } } /** * 修改已有配置项的value * * @param key 需要保存的KEY * @param type 需要保存的KEY对应的类型 * @param value 需要保存的值 */ private void updateProperty(String key,String value) { StringBuffer query = new StringBuffer("UPDATE " + this.table + " SET "); if (this.typeColumn == null) { query.append(this.valueColumn + " = ? WHERE " + this.keyColumn + " = ? "); } else { query.append(this.valueColumn + " = ? WHERE " + this.keyColumn + " = ? AND " + this.typeColumn + " = ? "); } Connection conn = null; PreparedStatement pstmt = null; try { conn = getConnection(); logger.debug(" updateProperty query :" + query.toString()); pstmt = conn.prepareStatement(query.toString()); int index = 1; pstmt.setString(index++,value); pstmt.setString(index++,key); if (this.typeColumn != null) { pstmt.setString(index++,type); } // 将修改项更新到数据库中 pstmt.executeUpdate(); // 将修改项更新到缓存中 if (this.typeColumn == null) { tab.put(key,value); } } catch (sqlException e) { logger.error("修改配置失败:key:" + key + ";type:" + type + ";value:" + value); } finally { close(conn,null); } } /** * 读取配置表，加载到本地缓存 */ private void readConfig() { if (this.tab == null) { this.tab = new Hashtable<String,String>(); } // 生成查询语句 StringBuffer query = null; if (this.typeColumn == null) { // 以keyColumn为主键时 query = new StringBuffer("SELECT " + this.keyColumn + "," + this.valueColumn + " FROM " + this.table); } else { // 以keyColumn与typeColumn为共同主键时 query = new StringBuffer("SELECT " + this.typeColumn + "," + this.keyColumn + "," + this.valueColumn + " FROM " + this.table); } Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; try { conn = getConnection(); logger.debug(" readConfig sql :" + query.toString()); pstmt = conn.prepareStatement(query.toString()); rs = pstmt.executeQuery(); while (rs.next()) { if (this.typeColumn == null) { // 以keyColumn为主键时 this.tab.put(rs.getString(1),rs.getString(2)); } else { // 以keyColumn与typeColumn为共同主键时 this.tab .put(rs.getString(1) + "|" + rs.getString(2),rs.getString(3)); } } } catch (sqlException e) { logger.error("加载配置信息失败"); } finally { close(conn,rs); } } /** * 获取数据库连接 * @return 数据库连接 */ private synchronized Connection getConnection() { Connection con = null; try { Class.forName(this.DB_PARAM[0]); } catch (Exception e) { logger.error("加载数据库驱动信息异常 "); } try { con = DriverManager.getConnection(this.DB_PARAM[1],this.DB_PARAM[2],this.DB_PARAM[3]); } catch (sqlException e) { logger.error("始初化数据库连接信息异常 "); } return con; } /** * 关闭相关数据库连接资源 * @param conn * @param stmt */ private void close(Connection conn,Statement stmt,ResultSet rs) { try { if (rs != null) { rs.close(); } } catch (sqlException e) { } try { if (stmt != null) { stmt.close(); } } catch (sqlException e) { } try { if (conn != null) { conn.close(); } } catch (sqlException e) { } } }