From 1b2cc8958b5c55b8130680f8feb86d922a02f348 Mon Sep 17 00:00:00 2001
From: lhl722 <lhl722@qq.com>
Date: Tue, 16 Sep 2014 10:23:19 +0800
Subject: [PATCH 1/4] add cache util

---
 pom.xml                                       |  28 +
 .../org/telap/util/cache/MemCachedPool.java   | 596 ++++++++++++++++++
 .../org/telap/util/cache/OSCacheWrapper.java  | 259 ++++++++
 3 files changed, 883 insertions(+)
 create mode 100644 src/main/java/org/telap/util/cache/MemCachedPool.java
 create mode 100644 src/main/java/org/telap/util/cache/OSCacheWrapper.java

diff --git a/pom.xml b/pom.xml
index 3579f33..4519e35 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,6 +26,11 @@
 				<enabled>true</enabled>
 			</releases>
 		</repository>
+		<repository>
+            <id>jboss-snapshots-repository</id>
+            <name>JBoss Snapshots Repository</name>
+            <url>https://repository.jboss.org/nexus/content/repositories/snapshots/</url>
+        </repository>
 	</repositories>
 
 	<dependencies>
@@ -101,6 +106,12 @@
 					<artifactId>slf4j-api</artifactId>
 					<groupId>org.slf4j</groupId>
 				</exclusion>
+				<exclusion>
+					<artifactId>
+						hibernate-commons-annotations
+					</artifactId>
+					<groupId>org.hibernate.common</groupId>
+				</exclusion>
 			</exclusions>
 		</dependency>
 		<dependency>
@@ -149,6 +160,23 @@
 			<artifactId>mysql-connector-java</artifactId>
 			<version>5.1.27</version>
 		</dependency>
+		
+		<dependency>
+			<groupId>org.hibernate.common</groupId>
+			<artifactId>hibernate-commons-annotations</artifactId>
+			<version>4.0.5-SNAPSHOT</version>
+		</dependency>
+		
+		<dependency>
+			<groupId>opensymphony</groupId>
+			<artifactId>oscache</artifactId>
+			<version>2.4.1</version>
+		</dependency>
+		<dependency>  
+		    <groupId>com.whalin</groupId>  
+		    <artifactId>Memcached-Java-Client</artifactId>  
+		    <version>3.0.1</version>  
+		</dependency>   
         
 <!--         <dependency>  
             <groupId>org.apache.activemq</groupId>  
diff --git a/src/main/java/org/telap/util/cache/MemCachedPool.java b/src/main/java/org/telap/util/cache/MemCachedPool.java
new file mode 100644
index 0000000..8b32827
--- /dev/null
+++ b/src/main/java/org/telap/util/cache/MemCachedPool.java
@@ -0,0 +1,596 @@
+/*
+ * Copyright Bruce Liang (ldcsaa@gmail.com)
+ *
+ * Version	: JessMA 3.4.1
+ * Author	: Bruce Liang
+ * Website	: http://www.jessma.org
+ * Project	: http://www.oschina.net/p/portal-basic
+ * Blog		: http://www.cnblogs.com/ldcsaa
+ * WeiBo	: http://weibo.com/u/1402935851
+ * QQ Group	: 75375912
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.telap.util.cache;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import com.whalin.MemCached.MemCachedClient;
+import com.whalin.MemCached.SockIOPool;
+import com.schooner.MemCached.ObjectTransCoder;
+import com.schooner.MemCached.SchoonerSockIOPool;
+import com.schooner.MemCached.TransCoder;
+
+/** MemCached Client 缓存池封装类，简化 MemCached 缓存操作 */
+public class MemCachedPool
+{
+	public static final String DEF_POOL_NAME				= "default";
+	public static final String DEF_ENCODING					= "UTF-8";
+	public static final boolean DEF_IS_TCP					= true;
+	public static final boolean DEF_IS_BINARY_PROTOCAL		= false;
+	public static final boolean DEF_IS_SANITIZE_KEYS		= true;
+	public static final boolean DEF_IS_PRIMITIVE_AS_STRING	= false;
+
+	public static final int DEF_POOL_MULTIPLIER				= 3;
+	public static final int DEF_INIT_CONN					= 5;
+	public static final int DEF_MIN_CONN					= 5;
+	public static final int DEF_MAX_CONN					= 100;
+	public static final int DEF_MAX_IDLE					= 1000 * 60 * 5;
+	public static final long DEF_MAX_BUSY_TIME				= 1000 * 30;
+	public static final long DEF_MAINT_SLEEP				= 1000 * 30;
+	public static final int DEF_SOCKET_TO					= 1000 * 3;
+	public static final int DEF_SOCKET_CONNECT_TO			= 1000 * 3;
+	public static final boolean DEF_IS_FAILOVER				= true;
+	public static final boolean DEF_IS_FAILBACK				= true;
+	public static final boolean DEF_IS_NAGLE				= false;
+	public static final boolean DEF_IS_ALIVE_CHECK			= false;
+	public static final int DEF_HASHING_ALG					= SchoonerSockIOPool.NATIVE_HASH;
+	public static final int DEF_BUFFER_SIZE					= 1024 * 1025;
+
+	public static final TransCoder DEF_TRANS_CODER			= new ObjectTransCoder();
+
+	private String poolName				= DEF_POOL_NAME;
+	private String defaultEncoding		= DEF_ENCODING;
+	private boolean tcp					= DEF_IS_TCP;
+	private boolean binaryProtocal		= DEF_IS_BINARY_PROTOCAL;
+	private boolean sanitizeKeys		= DEF_IS_SANITIZE_KEYS;
+	private boolean primitiveAsString	= DEF_IS_PRIMITIVE_AS_STRING;
+
+	private int initConn				= DEF_INIT_CONN;
+	private int minConn					= DEF_MIN_CONN;
+	private int maxConn					= DEF_MAX_CONN;
+	private int maxIdle					= DEF_MAX_IDLE;
+	private long maxBusyTime			= DEF_MAX_BUSY_TIME;
+	private long maintSleep				= DEF_MAINT_SLEEP;
+	private int socketTO				= DEF_SOCKET_TO;
+	private int socketConnectTO			= DEF_SOCKET_CONNECT_TO;
+	private boolean failover			= DEF_IS_FAILOVER;
+	private boolean failback			= DEF_IS_FAILBACK;
+	private boolean nagle				= DEF_IS_NAGLE;
+	private boolean aliveCheck			= DEF_IS_ALIVE_CHECK;
+	private int hashingAlg				= DEF_HASHING_ALG;
+	private int bufferSize				= DEF_BUFFER_SIZE;
+
+	private TransCoder transCoder		= DEF_TRANS_CODER;
+
+	private String[] servers	= null;
+	private Integer[] weights	= null;
+
+	private SockIOPool pool		= null;
+	private MemCachedClient mcc	= null;
+
+	private static Map<String, MemCachedPool> instances = new HashMap<String, MemCachedPool>();
+
+	/** 获取默认缓存池实例（如果没有则进行创建） */
+	public static MemCachedPool getInstance()
+	{
+		return getInstance(DEF_POOL_NAME);
+	}
+
+	/** 获取指定名称的缓存池实例（如果没有则进行创建） */
+	synchronized public static MemCachedPool getInstance(String poolName)
+	{
+		MemCachedPool cache = instances.get(poolName);
+
+		if(cache == null)
+		{
+			cache = new MemCachedPool();
+			cache.poolName = poolName;
+
+			instances.put(cache.poolName, cache);
+		}
+
+		return cache;
+	}
+	
+	/** 删除默认缓存池实例 */
+	public static boolean removeInstance()
+	{
+		return removeInstance(DEF_POOL_NAME);
+	}
+	
+	/** 删除指定名称的缓存池实例 */
+	synchronized public static boolean removeInstance(String poolName)
+	{
+		MemCachedPool cache = instances.remove(poolName);
+		
+		if(cache != null)
+			cache.unInitialize();
+
+		return cache != null;
+	}
+
+	/** 删除所有缓存池 */
+	synchronized public static void shutdown()
+	{	
+		Set<Map.Entry<String, MemCachedPool>> entries = instances.entrySet();
+		
+		for(Map.Entry<String, MemCachedPool> entry : entries)
+			entry.getValue().unInitialize();
+		
+		instances.clear();
+	}
+
+	/** 获取默认缓存池内部的 {@link SockIOPool} 对象 */
+	public static SockIOPool getSockIOPool()
+	{
+		return getSockIOPool(DEF_POOL_NAME);
+	}
+
+	/** 获取指定名称的缓存池内部的 {@link SockIOPool} 对象 */
+	public static SockIOPool getSockIOPool(String poolName)
+	{
+		SockIOPool pool		= null;
+		MemCachedPool cache	= instances.get(poolName);
+
+		if(cache != null)
+			pool = cache.pool;
+
+		return pool;
+	}
+
+	/** 获取默认缓存池内部的 {@link MemCachedClient} 对象 */
+	public static MemCachedClient getCachedClient()
+	{
+		return getCachedClient(DEF_POOL_NAME);
+	}
+
+	/** 获取指定名称的缓存池内部的 {@link MemCachedClient} 对象 */
+	public static MemCachedClient getCachedClient(String poolName)
+	{
+		MemCachedClient client	= null;
+		MemCachedPool cache		= instances.get(poolName);
+
+		if(cache != null)
+			client = cache.mcc;
+
+		return client;
+	}
+
+	/** 根据默认缓存池内部的 {@link SockIOPool} 创建相应的 {@link MemCachedClient} 对象 */
+	public static MemCachedClient createCachedClient()
+	{
+		return createCachedClient(DEF_POOL_NAME);
+	}
+	
+	/** 根据默认缓存池内部的 {@link SockIOPool} 创建相应的 {@link MemCachedClient} 对象，并指定是否使用 TCP 连接 */
+	public static MemCachedClient createCachedClient(boolean tcp)
+	{
+		return createCachedClient(DEF_POOL_NAME, tcp);
+	}
+
+	/** 根据指定名称的缓存池内部的 {@link SockIOPool} 创建相应的 {@link MemCachedClient} 对象 */
+	public static MemCachedClient createCachedClient(String poolName)
+	{
+		MemCachedPool cache = instances.get(poolName);
+		
+		if(cache != null)
+			return createCachedClient(poolName, cache.tcp);
+		
+		return null;
+	}
+	
+	/** 根据指定名称的缓存池内部的 {@link SockIOPool} 创建相应的 {@link MemCachedClient} 对象，并指定是否使用 TCP 连接 */
+	public static MemCachedClient createCachedClient(String poolName, boolean tcp)
+	{
+		MemCachedClient client = null;
+		MemCachedPool cache = instances.get(poolName);
+
+		if(cache != null)
+		{
+			client = new MemCachedClient(cache.poolName, tcp, cache.binaryProtocal);
+
+			client.setDefaultEncoding(cache.defaultEncoding);
+			client.setPrimitiveAsString(cache.primitiveAsString);
+			client.setSanitizeKeys(cache.sanitizeKeys);
+			client.setTransCoder(cache.transCoder);
+		}
+
+		return client;
+	}
+
+	/** 初始化缓存池并创建缓存池内部的 {@link SockIOPool} 和 {@link MemCachedClient} 对象 */
+	synchronized public boolean initialize()
+	{
+		if(!hasInitialized())
+		{
+			pool = SockIOPool.getInstance(poolName, tcp);
+
+			pool.setAliveCheck(aliveCheck);
+			pool.setBufferSize(bufferSize);
+			pool.setFailback(failback);
+			pool.setFailover(failover);
+			pool.setHashingAlg(hashingAlg);
+			pool.setInitConn(initConn);
+			pool.setMaintSleep(maintSleep);
+			pool.setMaxBusyTime(maxBusyTime);
+			pool.setMaxConn(maxConn);
+			pool.setMaxIdle(maxIdle);
+			pool.setMinConn(minConn);
+			pool.setNagle(nagle);
+			pool.setSocketConnectTO(socketConnectTO);
+			pool.setSocketTO(socketTO);
+			pool.setServers(servers);
+			pool.setWeights(weights);
+			pool.initialize();
+
+			mcc = createCachedClient(poolName, tcp);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/** 检查缓存池是否已被初始化 */
+	public boolean hasInitialized()
+	{
+		return pool != null && pool.isInitialized();
+	}
+
+	/** 关闭缓存池，并清除缓存池内部的 {@link SockIOPool} 和 {@link MemCachedClient} 对象 */
+	synchronized public void unInitialize()
+	{
+		if(hasInitialized())
+		{
+			pool.shutDown();
+
+			pool	= null;
+			mcc		= null;
+		}
+	}
+
+	/** 参考：{@link MemCachedClient#setDefaultEncoding} */
+	public String getDefaultEncoding()
+	{
+		return defaultEncoding;
+	}
+
+	/** 参考：{@link MemCachedClient#setDefaultEncoding} */
+	public void setDefaultEncoding(String defaultEncoding)
+	{
+		if(hasInitialized())
+			throw new IllegalStateException("the MemCached Pool had been initialized, can not modify attrs.");
+		
+		this.defaultEncoding = defaultEncoding;
+	}
+
+	/** 获取：是否使用 TCP 协议 */
+	public boolean isTcp()
+	{
+		return tcp;
+	}
+
+	/** 设置：是否使用 TCP 协议 */
+	public void setTcp(boolean tcp)
+	{
+		checkModifyAttrs();
+
+		this.tcp = tcp;
+	}
+
+	/** 获取：是否使用二进制协议 */
+	public boolean isBinaryProtocal()
+	{
+		return binaryProtocal;
+	}
+
+	/** 设置：是否使用二进制协议 */
+	public void setBinaryProtocal(boolean binaryProtocal)
+	{
+		checkModifyAttrs();
+
+		this.binaryProtocal = binaryProtocal;
+	}
+
+	/** 参考：{@link MemCachedClient#setSanitizeKeys} */
+	public boolean isSanitizeKeys()
+	{
+		return sanitizeKeys;
+	}
+
+	/** 参考：{@link MemCachedClient#setSanitizeKeys} */
+	public void setSanitizeKeys(boolean sanitizeKeys)
+	{
+		checkModifyAttrs();
+
+		this.sanitizeKeys = sanitizeKeys;
+	}
+
+	/** 参考：{@link MemCachedClient#setPrimitiveAsString} */
+	public boolean isPrimitiveAsString()
+	{
+		return primitiveAsString;
+	}
+
+	/** 参考：{@link MemCachedClient#setPrimitiveAsString} */
+	public void setPrimitiveAsString(boolean primitiveAsString)
+	{
+		checkModifyAttrs();
+
+		this.primitiveAsString = primitiveAsString;
+	}
+
+	/** 参考：{@link SockIOPool#getInitConn} */
+	public int getInitConn()
+	{
+		return initConn;
+	}
+
+	/** 参考：{@link SockIOPool#setInitConn} */
+	public void setInitConn(int initConn)
+	{
+		checkModifyAttrs();
+
+		this.initConn = initConn;
+	}
+
+	/** 参考：{@link SockIOPool#getMinConn} */
+	public int getMinConn()
+	{
+		return minConn;
+	}
+
+	/** 参考：{@link SockIOPool#setMinConn} */
+	public void setMinConn(int minConn)
+	{
+		checkModifyAttrs();
+
+		this.minConn = minConn;
+	}
+
+	/** 参考：{@link SockIOPool#getMaxConn} */
+	public int getMaxConn()
+	{
+		return maxConn;
+	}
+
+	/** 参考：{@link SockIOPool#setMaxConn} */
+	public void setMaxConn(int maxConn)
+	{
+		checkModifyAttrs();
+
+		this.maxConn = maxConn;
+	}
+
+	/** 参考：{@link SockIOPool#getMaxIdle} */
+	public int getMaxIdle()
+	{
+		return maxIdle;
+	}
+
+	/** 参考：{@link SockIOPool#setMaxIdle} */
+	public void setMaxIdle(int maxIdle)
+	{
+		checkModifyAttrs();
+
+		this.maxIdle = maxIdle;
+	}
+
+	/** 参考：{@link SockIOPool#setMaxBusyTime} */
+	public long getMaxBusyTime()
+	{
+		return maxBusyTime;
+	}
+
+	/** 参考：{@link SockIOPool#setMaxBusyTime} */
+	public void setMaxBusyTime(long maxBusyTime)
+	{
+		checkModifyAttrs();
+
+		this.maxBusyTime = maxBusyTime;
+	}
+
+	/** 参考：{@link SockIOPool#getMaintSleep} */
+	public long getMaintSleep()
+	{
+		return maintSleep;
+	}
+
+	/** 参考：{@link SockIOPool#setMaintSleep} */
+	public void setMaintSleep(long maintSleep)
+	{
+		checkModifyAttrs();
+
+		this.maintSleep = maintSleep;
+	}
+
+	/** 参考：{@link SockIOPool#getSocketTO} */
+	public int getSocketTO()
+	{
+		return socketTO;
+	}
+
+	/** 参考：{@link SockIOPool#setSocketTO} */
+	public void setSocketTO(int socketTO)
+	{
+		checkModifyAttrs();
+
+		this.socketTO = socketTO;
+	}
+
+	/** 参考：{@link SockIOPool#getSocketConnectTO} */
+	public int getSocketConnectTO()
+	{
+		return socketConnectTO;
+	}
+
+	/** 参考：{@link SockIOPool#setSocketConnectTO} */
+	public void setSocketConnectTO(int socketConnectTO)
+	{
+		checkModifyAttrs();
+
+		this.socketConnectTO = socketConnectTO;
+	}
+
+	/** 参考：{@link SockIOPool#getFailover} */
+	public boolean isFailover()
+	{
+		return failover;
+	}
+
+	/** 参考：{@link SockIOPool#setFailover} */
+	public void setFailover(boolean failover)
+	{
+		checkModifyAttrs();
+
+		this.failover = failover;
+	}
+
+	/** 参考：{@link SockIOPool#getFailback} */
+	public boolean isFailback()
+	{
+		return failback;
+	}
+
+	/** 参考：{@link SockIOPool#setFailback} */
+	public void setFailback(boolean failback)
+	{
+		checkModifyAttrs();
+
+		this.failback = failback;
+	}
+
+	/** 参考：{@link SockIOPool#getNagle} */
+	public boolean isNagle()
+	{
+		return nagle;
+	}
+
+	/** 参考：{@link SockIOPool#setNagle} */
+	public void setNagle(boolean nagle)
+	{
+		checkModifyAttrs();
+
+		this.nagle = nagle;
+	}
+
+	/** 参考：{@link SockIOPool#getAliveCheck} */
+	public boolean isAliveCheck()
+	{
+		return aliveCheck;
+	}
+
+	/** 参考：{@link SockIOPool#setAliveCheck} */
+	public void setAliveCheck(boolean aliveCheck)
+	{
+		checkModifyAttrs();
+
+		this.aliveCheck = aliveCheck;
+	}
+
+	/** 参考：{@link SockIOPool#getHashingAlg} */
+	public int getHashingAlg()
+	{
+		return hashingAlg;
+	}
+
+	/** 参考：{@link SockIOPool#setHashingAlg} */
+	public void setHashingAlg(int hashingAlg)
+	{
+		checkModifyAttrs();
+
+		this.hashingAlg = hashingAlg;
+	}
+
+	/** 参考：{@link SockIOPool#getBufferSize} */
+	public int getBufferSize()
+	{
+		return bufferSize;
+	}
+
+	/** 参考：{@link SockIOPool#setBufferSize} */
+	public void setBufferSize(int bufferSize)
+	{
+		checkModifyAttrs();
+
+		this.bufferSize = bufferSize;
+	}
+
+	/** 参考：{@link MemCachedClient#setTransCoder} */
+	public TransCoder getTransCoder()
+	{
+		return transCoder;
+	}
+
+	/** 参考：{@link MemCachedClient#setTransCoder} */
+	public void setTransCoder(TransCoder transCoder)
+	{
+		checkModifyAttrs();
+
+		this.transCoder = transCoder;
+	}
+
+	/** 参考：{@link SockIOPool#getServers} */
+	public String[] getServers()
+	{
+		return servers;
+	}
+
+	/** 参考：{@link SockIOPool#setServers} */
+	public void setServers(String ... servers)
+	{
+		checkModifyAttrs();
+
+		this.servers = servers;
+	}
+
+	/** 参考：{@link SockIOPool#getWeights} */
+	public Integer[] getWeights()
+	{
+		return weights;
+	}
+
+	/** 参考：{@link SockIOPool#setWeights} */
+	public void setWeights(Integer ... weights)
+	{
+		checkModifyAttrs();
+
+		this.weights = weights;
+	}
+
+	/** 参考：{@link SockIOPool} */
+	public String getPoolName()
+	{
+		return poolName;
+	}
+
+	private void checkModifyAttrs()
+	{
+		if(hasInitialized())
+			throw new IllegalStateException("the MemCached Pool had been initialized, can not modify attrs.");
+	}
+}
diff --git a/src/main/java/org/telap/util/cache/OSCacheWrapper.java b/src/main/java/org/telap/util/cache/OSCacheWrapper.java
new file mode 100644
index 0000000..28c76ae
--- /dev/null
+++ b/src/main/java/org/telap/util/cache/OSCacheWrapper.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright Bruce Liang (ldcsaa@gmail.com)
+ *
+ * Version	: JessMA 3.4.1
+ * Author	: Bruce Liang
+ * Website	: http://www.jessma.org
+ * Project	: http://www.oschina.net/p/portal-basic
+ * Blog		: http://www.cnblogs.com/ldcsaa
+ * WeiBo	: http://weibo.com/u/1402935851
+ * QQ Group	: 75375912
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.telap.util.cache;
+
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.commons.lang.StringUtils;
+
+import com.opensymphony.oscache.base.Cache;
+import com.opensymphony.oscache.base.CacheEntry;
+import com.opensymphony.oscache.base.EntryRefreshPolicy;
+import com.opensymphony.oscache.base.NeedsRefreshException;
+import com.opensymphony.oscache.general.GeneralCacheAdministrator;
+
+/**
+ * 
+ * OSCache 缓存帮助类（简化 OSCache 缓存操作）
+ *
+ */
+public class OSCacheWrapper
+{
+	// 默认过期时间(单位为秒);
+	private int defaultRefreshPeriod;
+	// 默认组
+	private String[]	 defaultGroups;
+	// 唯一 CacheAdmin 实例
+	private static GeneralCacheAdministrator instance;
+
+	public OSCacheWrapper()
+	{
+		this(CacheEntry.INDEFINITE_EXPIRY);
+	}
+
+	public OSCacheWrapper(String ... defaultGroups)
+	{
+		this(CacheEntry.INDEFINITE_EXPIRY, defaultGroups);
+	}
+	
+	public OSCacheWrapper(int defaultRefreshPeriod)
+	{
+		this(defaultRefreshPeriod, new String[]{});
+	}
+
+	public OSCacheWrapper(int defaultRefreshPeriod, String ... defaultGroups)
+	{
+		this.defaultRefreshPeriod = defaultRefreshPeriod;
+		
+		if(defaultGroups.length > 0)
+		{
+			Set<String> groups = new HashSet<String>();
+			for(String group : defaultGroups)
+			{
+				if(StringUtils.isNotEmpty(group))
+					groups.add(group);
+			}
+			
+			if(!groups.isEmpty())
+			{
+				this.defaultGroups	= new String[groups.size()];
+				groups.toArray(this.defaultGroups);
+			}
+			else
+				this.defaultGroups =  null;
+		}
+		else
+			this.defaultGroups =  null;
+
+		if(instance == null)
+			createCacheAdminInstance();
+	}
+
+	private static GeneralCacheAdministrator createCacheAdminInstance()
+	{
+		if(instance == null)
+		{
+			synchronized(OSCacheWrapper.class)
+			{
+				if(instance == null)
+					instance = new GeneralCacheAdministrator();
+			}
+		}
+
+		return instance;
+	}
+	
+	public <T> void put(String key, T content)
+	{
+		getCache().putInCache(key, content, defaultGroups, null, null);
+	}
+
+	public <T> void put(String key, T content, EntryRefreshPolicy policy)
+	{
+		getCache().putInCache(key, content, defaultGroups, policy, null);
+	}
+
+	public <T> void put(String key, T content, String ... groups)
+	{
+		if(groups.length == 0)
+			groups = null;
+		
+		getCache().putInCache(key, content, groups, null, null);
+	}
+
+	public <T> void put(String key, T content, EntryRefreshPolicy policy, String ... groups)
+	{
+		if(groups.length == 0)
+			groups = null;
+		
+		getCache().putInCache(key, content, groups, policy, null);
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key)
+	{
+		Object obj = null;
+		
+		try
+		{
+			obj = getCache().getFromCache(key, defaultRefreshPeriod);
+		}
+		catch(NeedsRefreshException e)
+		{
+			cancelUpdate(key);
+		}
+		
+		return (T)obj;
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key, int refreshPeriod)
+	{
+		Object obj = null;
+		
+		try
+		{
+			obj = getCache().getFromCache(key, refreshPeriod);
+		}
+		catch(NeedsRefreshException e)
+		{
+			cancelUpdate(key);
+		}
+		
+		return (T)obj;
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key, int refreshPeriod, String cronExpression)
+	{
+		Object obj = null;
+		
+		try
+		{
+			obj = getCache().getFromCache(key, refreshPeriod, cronExpression);
+		}
+		catch(NeedsRefreshException e)
+		{
+			cancelUpdate(key);
+		}
+		
+		return (T)obj;
+	}
+	
+	public GeneralCacheAdministrator getAdministrator()
+	{
+		return instance;
+	}
+	
+	public Cache getCache()
+	{
+		return instance.getCache();
+	}
+	
+	public void cancelUpdate(String key)
+	{
+		getCache().cancelUpdate(key);
+	}
+
+	public void remove(String key)
+	{
+		getCache().removeEntry(key);
+	}
+
+	public void flushAll()
+	{
+		instance.flushAll();
+	}
+
+	public void flushAll(Date date)
+	{
+		getCache().flushAll(date);
+	}
+	
+	public void flushAll(Date date, String origin)
+	{
+		getCache().flushAll(date, origin);
+	}
+
+	public void flushEntry(String key)
+	{
+		getCache().flushEntry(key);
+	}
+
+	public void flushEntry(String key, String origin)
+	{
+		getCache().flushEntry(key, origin);
+	}
+	
+	public void flushGroup()
+	{
+		if(defaultGroups != null)
+		{
+			for(String group : defaultGroups)
+				getCache().flushGroup(group);
+		}
+	}
+	
+	public void flushGroup(String group)
+	{
+		getCache().flushGroup(group);
+	}
+	
+	public void flushGroup(String group, String origin)
+	{
+		getCache().flushGroup(group, origin);
+	}
+	
+	public static void shutdown()
+	{
+		synchronized(OSCacheWrapper.class)
+		{
+			instance.destroy();
+			instance = null;		
+		}
+	}
+}

From a24fb5a9e55cf7365472032715dcbf34422ad5b9 Mon Sep 17 00:00:00 2001
From: lhl722 <lhl722@qq.com>
Date: Tue, 16 Sep 2014 12:09:01 +0800
Subject: [PATCH 2/4] add log4j2 config

---
 src/main/resources/log4j2.xml | 62 ++++++++++++++++++++++++-----------
 1 file changed, 42 insertions(+), 20 deletions(-)

diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
index 8a30a55..3e451e1 100644
--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
@@ -1,20 +1,42 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Configuration>
-    <Appenders>
-        <Console name="Console" target="SYSTEM_OUT">
-            <PatternLayout pattern="%p [%t] %c{1}.%M(%L) | %m%n"/>
-        </Console>
-    </Appenders>
-
-    <Loggers>
-        <Logger name="org.apache" level="warn"/>
-        <Logger name="org.hibernate" level="warn"/>
-        <Logger name="org.hibernate.SQL" level="warn"/>
-        <Logger name="org.springframework" level="warn"/>
-        <Logger name="org.appfuse" level="debug"/>
-
-        <Root level="warn">
-            <AppenderRef ref="Console"/>
-        </Root>
-    </Loggers>
-</Configuration>
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration>
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%p [%t] %c{1}.%M(%L) | %m%n"/>
+        </Console>
+        <RollingRandomAccessFile name="ROLLFILE" fileName="${sys:catalina.home}/logs/telap.log"
+								 filePattern="$${sys:catalina.home}/logs/$${date:yyyy-MM}/telap-%d{yyyy-MM-dd}-%i.log.gz">
+			<ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY" />
+			<PatternLayout pattern="%d{ABSOLUTE} &lt;%c&gt; %5p [%t]: %m%n"/>
+			<Policies>
+				<TimeBasedTriggeringPolicy />
+			</Policies>
+			<DefaultRolloverStrategy />
+		</RollingRandomAccessFile>
+    </Appenders>
+
+    <Loggers>
+        <Root level="INFO">
+            <AppenderRef ref="Console"/>
+        </Root>
+        <Logger name="org.apache" level="DEBUG" additivity="false">
+        	<AppenderRef ref="Console" />	
+        </Logger>
+        <Logger name="org.hibernate" level="DEBUG" additivity="false">
+        	<AppenderRef ref="Console" />	
+        </Logger>
+        <Logger name="org.hibernate.SQL" level="DEBUG" additivity="false">
+        	<AppenderRef ref="Console" />	
+        </Logger>
+        <Logger name="org.springframework" level="DEBUG" additivity="false">
+        	<AppenderRef ref="Console"/>
+        </Logger>
+		<Logger name="java.sql" level="DEBUG" additivity="false">
+			<AppenderRef ref="Console" />		
+		</Logger>
+		<Logger name="org.telap" level="DEBUG" additivity="false">
+			<AppenderRef ref="Console" />
+			<AppenderRef ref="ROLLFILE" />			
+		</Logger>
+    </Loggers>
+</Configuration>
\ No newline at end of file

From 7f890218db080790bb0e53e9826c488df6441db2 Mon Sep 17 00:00:00 2001
From: lhl722 <lhl722@qq.com>
Date: Tue, 16 Sep 2014 12:27:15 +0800
Subject: [PATCH 3/4] modify log4j2

---
 src/main/resources/log4j2.xml | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
index 3e451e1..899508c 100644
--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
@@ -19,23 +19,12 @@
         <Root level="INFO">
             <AppenderRef ref="Console"/>
         </Root>
-        <Logger name="org.apache" level="DEBUG" additivity="false">
-        	<AppenderRef ref="Console" />	
-        </Logger>
-        <Logger name="org.hibernate" level="DEBUG" additivity="false">
-        	<AppenderRef ref="Console" />	
-        </Logger>
-        <Logger name="org.hibernate.SQL" level="DEBUG" additivity="false">
-        	<AppenderRef ref="Console" />	
-        </Logger>
-        <Logger name="org.springframework" level="DEBUG" additivity="false">
-        	<AppenderRef ref="Console"/>
-        </Logger>
-		<Logger name="java.sql" level="DEBUG" additivity="false">
-			<AppenderRef ref="Console" />		
-		</Logger>
+        <Logger name="org.apache" level="DEBUG" />
+        <Logger name="org.hibernate" level="DEBUG" />
+        <Logger name="org.hibernate.SQL" level="DEBUG"/>
+        <Logger name="org.springframework" level="DEBUG" />
+		<Logger name="java.sql" level="DEBUG" />
 		<Logger name="org.telap" level="DEBUG" additivity="false">
-			<AppenderRef ref="Console" />
 			<AppenderRef ref="ROLLFILE" />			
 		</Logger>
     </Loggers>

From dbd1c09c8a5a05e45a3b7519b48bbaccd5707a5c Mon Sep 17 00:00:00 2001
From: lhl722 <lhl722@qq.com>
Date: Wed, 24 Sep 2014 10:52:02 +0800
Subject: [PATCH 4/4] add util

---
 src/main/java/org/telap/util/RequestUtil.java | 113 ++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 src/main/java/org/telap/util/RequestUtil.java

diff --git a/src/main/java/org/telap/util/RequestUtil.java b/src/main/java/org/telap/util/RequestUtil.java
new file mode 100644
index 0000000..07b8a21
--- /dev/null
+++ b/src/main/java/org/telap/util/RequestUtil.java
@@ -0,0 +1,113 @@
+package org.telap.util;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * Convenience class for setting and retrieving cookies.
+ */
+public final class RequestUtil {
+    private static final Log log = LogFactory.getLog(RequestUtil.class);
+
+    /**
+     * Checkstyle rule: utility classes should not have public constructor
+     */
+    private RequestUtil() {
+    }
+
+    /**
+     * Convenience method to set a cookie
+     *
+     * @param response the current response
+     * @param name the name of the cookie
+     * @param value the value of the cookie
+     * @param path the path to set it on
+     */
+    public static void setCookie(HttpServletResponse response, String name,
+                                 String value, String path) {
+        if (log.isDebugEnabled()) {
+            log.debug("Setting cookie '" + name + "' on path '" + path + "'");
+        }
+
+        Cookie cookie = new Cookie(name, value);
+        cookie.setSecure(false);
+        cookie.setPath(path);
+        cookie.setMaxAge(3600 * 24 * 30); // 30 days
+
+        response.addCookie(cookie);
+    }
+
+    /**
+     * Convenience method to get a cookie by name
+     *
+     * @param request the current request
+     * @param name the name of the cookie to find
+     *
+     * @return the cookie (if found), null if not found
+     */
+    public static Cookie getCookie(HttpServletRequest request, String name) {
+        Cookie[] cookies = request.getCookies();
+        Cookie returnCookie = null;
+
+        if (cookies == null) {
+            return returnCookie;
+        }
+
+        for (final Cookie thisCookie : cookies) {
+            if (thisCookie.getName().equals(name) && !"".equals(thisCookie.getValue())) {
+                returnCookie = thisCookie;
+                break;
+            }
+        }
+
+        return returnCookie;
+    }
+
+    /**
+     * Convenience method for deleting a cookie by name
+     *
+     * @param response the current web response
+     * @param cookie the cookie to delete
+     * @param path the path on which the cookie was set (i.e. /appfuse)
+     */
+    public static void deleteCookie(HttpServletResponse response,
+                                    Cookie cookie, String path) {
+        if (cookie != null) {
+            // Delete the cookie by setting its maximum age to zero
+            cookie.setMaxAge(0);
+            cookie.setPath(path);
+            response.addCookie(cookie);
+        }
+    }
+
+    /**
+     * Convenience method to get the application's URL based on request
+     * variables.
+     * 
+     * @param request the current request
+     * @return URL to application
+     */
+    public static String getAppURL(HttpServletRequest request) {
+        if (request == null) return "";
+        
+        StringBuffer url = new StringBuffer();
+        int port = request.getServerPort();
+        if (port < 0) {
+            port = 80; // Work around java.net.URL bug
+        }
+        String scheme = request.getScheme();
+        url.append(scheme);
+        url.append("://");
+        url.append(request.getServerName());
+        if ((scheme.equals("http") && (port != 80)) || (scheme.equals("https") && (port != 443))) {
+            url.append(':');
+            url.append(port);
+        }
+        url.append(request.getContextPath());
+        return url.toString();
+    }
+}