在高并发的场景里面经常会使用到localcache内容，但是一直没有一个很好的内存管理工具。在开发的时候发现了ehcache，这么一个开源的工具。唯一的缺点就是无法对于多块数据单元进行一个有效的管理，并且在数据过期的时候无法提供有效的更新机制，所以这里写了一个数据缓存池来满足这个需求。
下面是设计组织结构：
这里主要是在数据实体内部封装了数据更新器，这样在数据过期的时候可以调用更新器的方法。
1. Ehcache数据缓冲的具体代码：（主要是get方法内部进行数据更新，使用对象锁的方式来进行数据过期的并发控制，缺点是可能在非常高的并发里面会出现数据阻塞的现象，但是因为这里大部分都是内存的运算操作，所以相对来说阻塞的效果还好）
package com.tmall.lafite.core.manager.localcache;
import java.util.List;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.concurrent.LockType;
import net.sf.ehcache.concurrent.ReadWriteLockSync;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.ResultCode;
/**
* cache数据实体
* @author wangxiao
*
*/
public class LafiteCache {
private CacheManager cacheManager = null;
private Cache cacheImpl = null;
ReadWriteLockSync rwLock = new ReadWriteLockSync();
private int capability = 30;
private long expireTime = 30;
public static final int DEFAULT_CAPABILITY = 30;
public static final int DEFAULT_EXPIRETIME = 30;
private String cacheName = "Tair Local Cache";
public LafiteCache(String id, int capability, long expireTimeMS) {
this.cacheName = id;
this.capability = capability;
this.expireTime = expireTimeMS;
}
public void setExpireTime(long expireTimeMS) {
this.expireTime = expireTimeMS;
}
public void setCapacity(int cap) {
cacheImpl.getCacheConfiguration().setMaxEntriesLocalHeap(cap);
}
public long getExpireTime() {
return expireTime;
}
@SuppressWarnings("deprecation")
public void initialize() {
CacheConfiguration cacheConfiguration = new CacheConfiguration();
cacheConfiguration.setDiskPersistent(false);
cacheConfiguration.name(cacheName)
.maxEntriesLocalHeap(capability)
.diskPersistent(false)
.memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU);
// .timeToLiveSeconds(expireTime);
//cacheConfiguration.transactionalMode("LOCAL");
//Configuration config = new Configuration().name(cacheName).cache(cacheConfiguration);
cacheManager = CacheManager.create();
cacheImpl = new Cache(cacheConfiguration);
cacheManager.addCache(cacheImpl);
//cache = MemoryStore.create(cacheImpl, new UnboundedPool());
}
public int size() {
return (int) cacheImpl.getSize();
}
public void destroy() {
cacheImpl.dispose();
//cacheManager.removeCache(cacheName);
cacheManager.shutdown();
}
public void clear() {
rwLock.lock(LockType.WRITE);
try {
cacheImpl.removeAll();
} finally {
rwLock.unlock(LockType.WRITE);
}
}
public void del(Object key) {
cacheImpl.remove(key);
return;
}
public void put(Object key, Object value) {
cacheImpl.put(new Element(key, value));
return ;
}
public LafiteResult get(Object key) {
LafiteResult lafiteResult = new LafiteResult();
Element element = cacheImpl.get(key);
if (element == null) {
lafiteResult.setError(ResultCode.Error.Cache.NO_DATA);
return lafiteResult;
}
long now = System.currentTimeMillis();
long pastTime = now - element.getLastUpdateTime();
if (pastTime >= expireTime) {
// double check
synchronized (element) {
pastTime = now - element.getLastUpdateTime();
if (pastTime >= expireTime) {
// expired, update entry
element.updateUpdateStatistics();
lafiteResult.setError(ResultCode.Error.Cache.DATA_OVERDUE);
}
}
}
// element object value never null;
lafiteResult.setDefaultModel(element.getObjectValue());
return lafiteResult;
}
@SuppressWarnings("unchecked")
public List<Object> getKeys() {
List<Object> keys = cacheImpl.getKeys();
return keys;
}
}2. 数据逻辑单元定义（这里封装了数据容器单元，把原来的数据池方法传入，在数据更新的时候使用namespace来获取内存实体，进而来获取数据。）
（注：这里目前还没有想好是否把数据的初始化放在容器当中，这里暂时不放入。只是在容器里面进行初始化方法的调用，真正的数据设置方式由逻辑单元获取数据池进行自身的put）
package com.tmall.lafite.core.manager.localcache.util;
import org.springframework.beans.factory.annotation.Autowired;
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.manager.localcache.LafiteContainer;
/**
* 缓存逻辑单元
* @author wangxiao
*
*/
public abstract class LogicCenter {
@Autowired
private LafiteContainer lafiteContainer;
/**
* 初始化方法
* @return
*/
public abstract Object initialize();
/**
* 回调函数
* @param lafiteCache
* @param key
* @return
*/
public abstract Object callBack(String namespace, Object key, LafiteResult lafiteResult);
public LafiteContainer getLafiteContainer() {
return lafiteContainer;
}
}package com.tmall.lafite.core.manager.localcache;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.ResultCode;
import com.tmall.lafite.core.manager.localcache.entity.CacheEntity;
import com.tmall.lafite.core.manager.localcache.util.LogicCenter;
/**
* cache容器
* @author wangxiao
*
*/
public class LafiteContainer {
protected final Logger logger = LoggerFactory.getLogger(LafiteContainer.class);
private Map<String, CacheEntity> cacheMap = new ConcurrentHashMap<String, CacheEntity>();
/**
* 注册缓存对象
* @param namespace
* @param key
* @param lafiteCache 缓存对象
* @param logicCenter 逻辑对象 （包含：初始化方法和callback方法）
* @return
*/
// public String register(String namespace, String key, LafiteCache lafiteCache, LogicCenter logicCenter) {
// if(namespace != null && StringUtils.isEmpty(key) && lafiteCache != null) {
// if(cacheMap.containsKey(namespace)) {
// return ResultCode.Error.Cache.NAMESPACE_REPETITION;
// }
//
// CacheEntity cacheEntity = new CacheEntity(lafiteCache, logicCenter);
// try {
// cacheEntity.initialize();
// } catch (Exception e) {
// logger.error("LafiteContainer.register ", e);
// }
// cacheMap.put(namespace, cacheEntity);
// return null;
// }
// return ResultCode.Error.Cache.COMMON_PARAM_LOST;
// }
/**
* 获取cache内的数据
* @param namespace
* @param key
* @return
*/
public LafiteResult get(String namespace, Object key) {
LafiteResult lafiteResult = new LafiteResult();
CacheEntity cacheEntity = cacheMap.get(namespace);//获取缓存实体
if(cacheEntity == null) {
lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
} else {
LafiteCache lafiteCache = cacheEntity.getLafiteCache();
LafiteResult result = lafiteCache.get(key);
if(ResultCode.Error.Cache.NO_DATA.equals(result.getError())
|| ResultCode.Error.Cache.DATA_OVERDUE.equals(result.getError())) {
cacheEntity.getLogicCenter().callBack(namespace, key, result);//数据过期触发callback事件
}
lafiteResult = result;
}
return lafiteResult;
}
/**
* 获取指定命名空间的全部数据
* 这里采用的是逐条遍历的方式
* @param namespace
* @return
*/
public LafiteResult getAll(String namespace) {
LafiteResult lafiteResult = new LafiteResult();
List<Object> objects = new ArrayList<Object>();
CacheEntity cacheEntity = cacheMap.get(namespace);
if(cacheEntity == null) {
lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
} else {
LafiteCache lafiteCache = cacheEntity.getLafiteCache();
List<Object> keys = lafiteCache.getKeys();
if(keys.isEmpty()) {
lafiteResult.setError(ResultCode.Error.Cache.NO_DATA);
} else {
for(Object key : keys) {
LafiteResult lr = get(namespace, key);
objects.add(lr.getDefaultModel());
}
}
}
lafiteResult.setDefaultModel(objects);
return lafiteResult;
}
/**
* 设置数据对象内容
* @param namespace
* @param key
* @param value
* @return
*/
public LafiteResult put(String namespace, Object key, Object value) {
LafiteResult lafiteResult = new LafiteResult();
CacheEntity cacheEntity = cacheMap.get(namespace);
if(cacheEntity == null) {
lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
} else {
LafiteCache lafiteCache = cacheEntity.getLafiteCache();
lafiteCache.put(key, value);
}
return lafiteResult;
}
public void setCacheMap(Map<String, CacheEntity> cacheMap) {
this.cacheMap = cacheMap;
}
public Map<String, CacheEntity> getCacheMap() {
return cacheMap;
}
public void initialize() {
new Thread(new Runnable() {
@Override
public void run() {
for(String key : cacheMap.keySet()) {
try {
CacheEntity cacheEntity = cacheMap.get(key);
if(cacheEntity != null) {
LogicCenter logicCenter = cacheEntity.getLogicCenter();
if(logicCenter != null) {
logicCenter.initialize();
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
}
}<!-- 权限角色缓存
<bean id="permitRoleCache" class="com.tmall.lafite.core.manager.localcache.LafiteCache" init-method="initialize">
<constructor-arg value="_permit_role_cache_"/>
<constructor-arg value="100"/>
<constructor-arg value="2000"/>
</bean>
<bean id="permitRoleLogicCenter" class="com.tmall.lafite.core.manager.permit.cache.PermitRoleLogicCenter"/>
<bean id="permitRoleCacheEntity" class="com.tmall.lafite.core.manager.localcache.entity.CacheEntity">
<property name="logicCenter" ref="permitRoleLogicCenter" />
<property name="lafiteCache" ref="permitRoleCache" />
</bean>
-->
<!-- 缓存容器 -->
<bean id="lafiteContainer" class="com.tmall.lafite.core.manager.localcache.LafiteContainer" init-method="initialize">
<!--
<property name="cacheMap">
<map>
<entry key="PermitCommon" value-ref="permitCommonCacheEntity" />
<entry key="PermitAlgorithm" value-ref="permitAlgorithmCacheEntity"/>
<entry key="PermitRole" value-ref="permitRoleCacheEntity"/>
</map>
</property>
-->
</bean>5. 使用示例
@Autowired
private LafiteContainer lafiteContainer;
private String namespace = LafiteNameSpace.PermitCommon;
@SuppressWarnings("unchecked")
@Transactional
public List<PermitCommonDO> getPermitDOCache() {
LafiteResult lafiteResult = lafiteContainer.getAll(namespace);
if(lafiteResult.getDefaultModel() != null) {
return (List<PermitCommonDO>) lafiteResult.getDefaultModel();
}
return null;
}
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
