系统配置内存缓存SystemConfiguration

先从数据库中取配置信息，数据库没有则从properties文件中取。

不用频繁读取数据库。

 

用一个静态的HashMap实现。

/**
 * 系统配置内存缓存
 *
 */
public class SystemConfiguration {

	private static final Logger logger = LoggerFactory.getLogger(SystemConfiguration.class);
	
	/**
	 * sysconfig.properties中配置信息
	 */
	private static Properties sysconfigprop;
	
	/**
	 * SYS_CONFIG表中配置信息
	 */
	private static Map<String, String> sysconfigdb;

	static {
		sysconfigprop = new Properties();
		try {
			sysconfigprop.load(SystemConfiguration.class.getClassLoader()
					.getResourceAsStream("sysconfig.properties"));
		} catch (IOException e) {
			logger.error("load sysconfig.properties failed...");
			e.printStackTrace();
		}
		loadDatabase();
	}
	
	/**
	 * 加载数据库中配置项
	 * com.vispractice.soa.lightesb.common.listener.EsbInitListener中调用
	 * 
	 */
	private static void loadDatabase() {
		logger.debug("loadDatabase begin...");
		
		sysconfigdb = new HashMap<String, String>();
		// 获取spring bean容器
		WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
		ISysConfigDao sysconfigdao = (ISysConfigDao) wac.getBean("iSysConfigDao");
		List<SysConfig> config = sysconfigdao.getAll();
		
		logger.debug("config [db] list :");
		
		for(SysConfig c : config){
			if(Constants.ENABLED_FLAG_Y.equals(c.getEnabledFlag())){
				logger.debug(c.toString());
				
				sysconfigdb.put(c.getConfigName(), c.getConfigValue());
			}
		}
		logger.debug("loadDatabase end...");
	}

	/**
	 * 获取配置值
	 * 如果有相同配置项，数据库中配置项优先级更高
	 * 
	 * @param name
	 * @return
	 */
	public static String getConfigByName(String name) {
		String config = sysconfigdb.get(name);
		if(config == null){
			config = sysconfigprop.getProperty(name);
			
			logger.debug("this config from properties... " + name + "=" + config);
		}
		return config;
	}
	
	/**
	 * 添加新属性到缓存
	 * 
	 * @param config
	 */
	public static void addOrUpdateToSysConfigDb(Map<String, String> config){
		logger.debug("addOrUpdateToSysConfigDb : " + config);
		
		// 同步
		synchronized (sysconfigdb){
			sysconfigdb.putAll(config);
		}
		
		logger.debug("sysconfigdb : " + sysconfigdb);
	}
	
	/**
	 * 从缓存中删除属性
	 * 
	 * @param configName
	 */
	public static void removeFromSysConfigDb(List<String> configName){
		logger.debug("removeFromSysConfigDb : " + configName);
		
		// 同步
		synchronized (sysconfigdb){
			for(String c : configName){
				sysconfigdb.remove(c);
			}
		}
		
		logger.debug("sysconfigdb : " + sysconfigdb);
	}
	
}

 

调用：

String serverHome = SystemConfiguration.getConfigByName(Constants.MIDDLEWARE_HOME); //serverHome
String proxyBuildPath = SystemConfiguration.getConfigByName(Constants.SRV_PKG_PATH); //proxyBuildPath
String address = SystemConfiguration.getConfigByName(Constants.SERVER_ADDRESS);

 。。

 

 例子2：

（将各种开关也放到缓存中，不用在使用时再查询）

import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Properties;

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

/**
 * 全局配置
 *
 */
public class SysConfigCache {

	private static final Logger logger = LoggerFactory.getLogger(SysConfigCache.class);
	/**
	 * sysconfig.properties中配置信息
	 */
	private static Properties sysconfigprop;
	/**
	 * SYS_CONFIG表中配置信息
	 */
	private static Map<String, String> sysconfigdb = new Hashtable<String, String>();
	/**
	 * 全局日志开关
	 */
	private static boolean logSwitch = true;
	
	private static boolean inited = false;
	
	private static boolean parameterCheck = true;
	
	private static boolean serviceAccess = false;

	public final static String LOG_SWITCH="log.switch";
	public final static String SRV_PARAMETER_CHECK_ACCESS="SRV_PARAMETER_CHECK_ACCESS";
	public final static String SERVICE_ACCESS = "SERVICE_ACCESS";
	
	static {
		sysconfigprop = new Properties();
		try {
			InputStream in = SysConfigCache.class.getClassLoader().getResourceAsStream("sysconfig.properties");
			if(in!=null){
				sysconfigprop.load(in);
				setProperty(LOG_SWITCH,sysconfigprop.getProperty(LOG_SWITCH));
				inited = true;
			}else{
				logger.error("failed to found sysconfig.properties file ");
			}
			
		} catch (IOException e) {
			logger.error("load sysconfig.properties failed...",e);
		}
	}
	
	/**
	 * 添加配置项
	 * @param key
	 * @param value
	 */
	public static void putSysConfigDB(String key,String value){
		if(sysconfigdb!=null){
			logger.debug("put ["+key+":"+value+"] into SysConfigCache.");
			sysconfigdb.put(key, value);
			setProperty(key,value);
		}
	}
	
	/**
	 * 获取配置值
	 * 如果有相同配置项，数据库中配置项优先级更高
	 * 
	 * @param name
	 * @return
	 */
	public static String getConfigByName(String name) {
		String config = sysconfigdb.get(name);
		if(config == null){
			config = sysconfigprop.getProperty(name);
			logger.debug("this config from properties... " + name + "=" + config);
		}
		return config;
	}
	
	/**
	 * 从缓存中删除属性
	 * 
	 * @param configName
	 */
	public static void removeFromSysConfigDb(List<String> configName){
		logger.debug("removeFromSysConfigDb : " + configName);
		// 同步
		synchronized (sysconfigdb){
			for(String c : configName){
				logger.debug("remove ["+c+"] from SysConfigCache.");
				sysconfigdb.remove(c);
				setProperty(c,null);
			}
		}
		logger.debug("sysconfigdb : " + sysconfigdb);
	}
	
	/**
	 * 从缓存中删除属性
	 * 
	 * @param configName
	 */
	public static void removeFromSysConfigDb(String configName){
		logger.debug("remove ["+configName+"] from SysConfigCache.");
		// 同步
		synchronized (sysconfigdb){
				sysconfigdb.remove(configName);
				setProperty(configName,null);
		}
		logger.debug("sysconfigdb : " + sysconfigdb);
	}
	
	private static void setProperty(String key,String value){
		if(SysConfigCache.LOG_SWITCH.equals(key)){
			SysConfigCache.setLogSwitch("1".equals(SysConfigCache.getConfigByName(SysConfigCache.LOG_SWITCH)));
		}
		if(SysConfigCache.SRV_PARAMETER_CHECK_ACCESS.equals(key)){
			SysConfigCache.setParameterCheck("1".equals(SysConfigCache.getConfigByName(SysConfigCache.SRV_PARAMETER_CHECK_ACCESS)));
		}
		
		if(SysConfigCache.SERVICE_ACCESS.equals(key)){
			SysConfigCache.setServiceAccess("1".equals(SysConfigCache.getConfigByName(SysConfigCache.SERVICE_ACCESS)));
		}
	}
	

	public static boolean isLogSwitch() {
		return logSwitch;
	}

	public static void setLogSwitch(boolean logSwitch) {
		SysConfigCache.logSwitch = logSwitch;
	}

	public static boolean isInited() {
		return inited;
	}

	public static void setInited(boolean inited) {
		SysConfigCache.inited = inited;
	}

	public static boolean isParameterCheck() {
		return parameterCheck;
	}

	public static void setParameterCheck(boolean parameterCheck) {
		SysConfigCache.parameterCheck = parameterCheck;
	}

	public static boolean isServiceAccess() {
		return serviceAccess;
	}

	public static void setServiceAccess(boolean serviceAccess) {
		SysConfigCache.serviceAccess = serviceAccess;
	}
	
}

 

 例子3：

简单Cache

import java.util.HashMap;
import java.util.List;

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

/**
 * 参数校验缓存类
 *
 */
public class ServiceDataCache {

	private static final Logger logger = LoggerFactory.getLogger(ServiceDataCache.class);
	private static HashMap<String,List> cache = new HashMap<String,List>();
	public static boolean checkAccess = false;

	/**
	 * 填充缓存
	 * @param serviceNameEn
	 * @param paramsList
	 */
	public static void setCache(String serviceNameEn, List paramsList){
		logger.info("set Data to Cache begin..");
		if(cache != null){
			if(!cache.containsKey(serviceNameEn)){
				cache.put(serviceNameEn, paramsList);			
			}
		}	
		
		logger.info("set Data to Cache end.");
	}
	
	
	/**
	 * 从缓存取数据
	 * @param serviceNameEn
	 * @return
	 */
	public static List GetCache(String serviceNameEn){
		logger.info("Get Data from Cache begin.");
		if(cache != null){
			if(cache.containsKey(serviceNameEn)){
				return cache.get(serviceNameEn);				
			}
			
		}
		return null;
	}
	
	
	/**
	 * 校验缓存中是否存在
	 * @param serviceNameEn
	 * @return
	 */
	public static boolean checkCacheExist(String serviceNameEn){
		logger.info("check Cache Exist begin.");
		if(cache != null){
			return cache.containsKey(serviceNameEn.trim());			
		}
		return false;
	}
}

 

 

。。