缓存

<!-- 缓存注解声明，使用注解缓存 -->
<cache:annotation-driven cache-manager="cacheManager" />


<!-- 指定ehcache.xml的位置 -->
<bean id="cacheManagerFactory"
class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"
p:configLocation="classpath:com/xml/ehcache.xml">
<property name="shared" value="true" />
</bean>


<!-- 声明缓存Manager -->
<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"
p:cacheManager-ref="cacheManagerFactory" />


<bean
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetClass" value="java.lang.System" />
<property name="targetMethod" value="setProperty" />
<property name="arguments">
<list>
<value>system.project_name</value>
<value>${system.project_name}</value>
</list>
</property>

</bean>

package com.other;


import java.util.ArrayList;


import org.apache.commons.collections.MapIterator;
import org.apache.commons.collections.map.LRUMap;


/**
 * @see <a href="http://crunchify.com/">We help customers create an effective
 *      online presence...</a>
 * @since 2015-11-10
 * @version 1.0.0
 */
public class MemoryCache<K, T> {


private long timeToLive;
private LRUMap cacheMap;


protected class CacheObject {
public long lastAccessed = System.currentTimeMillis();
public T value;


protected CacheObject(T value) {
this.value = value;
}
}


public MemoryCache(long crunchifyTimeToLive, final long crunchifyTimerInterval, int maxItems) {
this.timeToLive = crunchifyTimeToLive * 1000;


cacheMap = new LRUMap(maxItems);


if (timeToLive > 0 && crunchifyTimerInterval > 0) {


Thread t = new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(crunchifyTimerInterval * 1000);
} catch (InterruptedException ex) {
}
cleanup();
}
}
});


t.setDaemon(true);
t.start();
}
} 


public void put(K key, T value) {
synchronized (cacheMap) {
cacheMap.put(key, new CacheObject(value));
}
}


@SuppressWarnings("unchecked")
public T get(K key) {
synchronized (cacheMap) {
CacheObject c = (CacheObject) cacheMap.get(key);


if (c == null)
return null;
else {
c.lastAccessed = System.currentTimeMillis();
return c.value;
}
}
}


public void remove(K key) {
synchronized (cacheMap) {
cacheMap.remove(key);
}
}


public int size() {
synchronized (cacheMap) {
return cacheMap.size();
}
}


@SuppressWarnings("unchecked")
public void cleanup() {


long now = System.currentTimeMillis();
ArrayList<K> deleteKey = null;


synchronized (cacheMap) {
MapIterator itr = cacheMap.mapIterator();


deleteKey = new ArrayList<K>((cacheMap.size() / 2) + 1);
K key = null;
CacheObject c = null;


while (itr.hasNext()) {
key = (K) itr.next();
c = (CacheObject) itr.getValue();


if (c != null && (now > (timeToLive + c.lastAccessed))) {
deleteKey.add(key);
}
}
}


for (K key : deleteKey) {
synchronized (cacheMap) {
cacheMap.remove(key);
}


Thread.yield();
}
}
}

package com.other.helper;


import com.other.MemoryCache;


/**
 * 2、会话暂存区域
 * @author Jackie
 * @since 2015-11-12
 * @version 1.0.0
 */
public class APPCacheHelp {

private static final Integer SESSION_LIVE_TIME   = 1 * 60 * 60 * 24 * 7; //7天
private static final Integer SESSION_INTERVAL_TIME = 1 * 60 * 60; //1小时
private static final Integer SESSION_MAX_ITEMS   = 100000; //100,000个

private static MemoryCache<String, String> appLoginSessionCache = new MemoryCache<String, String>(SESSION_LIVE_TIME, SESSION_INTERVAL_TIME, SESSION_MAX_ITEMS);
private APPCacheHelp() {
super();
}

/**
* 登录会话存储
* @param token 登录令牌
* @param userId 用户ID
*/
public static void put(String token,String userId){
appLoginSessionCache.put(token, userId);
}

/**
* 获取会话
* @param token 登录令牌
* @return 用户ID
*/
public static String get(String token){
return appLoginSessionCache.get(token);
}

/**
* 移除会话
* @param token 登录令牌
*/
public static void remove(String token){
appLoginSessionCache.remove(token);
}

}