cache策略(四)oscache

cache策略(四)oscache

oscache的实现，一个是实现cache接口，一个是实现provider接口，这样就可以配置在
cacheManager中使用了，其实其他的cache也可以参考这个实现来做
OSCache.java 如下：
package com.sillycat.easyview.plugin.cache.oscache;

import java.util.Date;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
import com.sillycat.easyview.plugin.cache.base.Cache;
import com.sillycat.easyview.plugin.cache.base.Timestamper;
import com.sillycat.easyview.plugin.commons.exceptions.CacheException;

/**
* OSCache 的代理实现
*/
public class OSCache implements Cache {

private static final Log log = LogFactory.getLog(OSCache.class);

private final int refreshPeriod;

private final String cron;

private final String regionName;

private GeneralCacheAdministrator cache = new GeneralCacheAdministrator();

private String toString(Object key) {
return String.valueOf(key) + '.' + regionName;
}

public OSCache(int refreshPeriod, String cron, String region) {
this.refreshPeriod = refreshPeriod;
this.cron = cron;
this.regionName = region;
}

public void setCacheCapacity(int cacheCapacity) {
cache.setCacheCapacity(cacheCapacity);
}

/**
* oscache 如果 get到的值为过期的话，则一定要cancelUpdate，否则线程会一直等待其它的线程将数据更新
*/
public Object get(Object key) throws CacheException {
try {
Object obj = cache.getFromCache(toString(key), refreshPeriod, cron);
return obj;
} catch (NeedsRefreshException e) {
if (log.isDebugEnabled()) {
log.debug(
"error then get:" + key + " from cache:" + regionName,
e);
}
cache.cancelUpdate(toString(key));
return null;
}
}

public Object read(Object key) throws CacheException {
return get(key);
}

public void update(Object key, Object value) throws CacheException {
put(key, value);
}

public void put(Object key, Object value) throws CacheException {
cache.putInCache(toString(key), value);
}

public void remove(Object key) throws CacheException {
cache.flushEntry(toString(key));
}

public void clear() throws CacheException {
cache.flushAll(new Date(System.currentTimeMillis() - 200));
}

public void destroy() throws CacheException {
cache.destroy();
}

public void lock(Object key) throws CacheException {
// local cache, so we use synchronization
}

public void unlock(Object key) throws CacheException {
// local cache, so we use synchronization
}

public long nextTimestamp() {
return Timestamper.next();
}

public int getTimeout() {
return Timestamper.ONE_MS * 60000; // ie. 60 seconds
}

public String getRegionName() {
return regionName;
}

public long getSizeInMemory() {
return -1;
}

public long getElementCountInMemory() {
return -1;
}

public long getElementCountOnDisk() {
return -1;
}

public Map toMap() {
throw new UnsupportedOperationException();
}

public String toString() {
return "OSCache(" + regionName + ')';
}
}

OsCacheProvider.java如下：
package com.sillycat.easyview.plugin.cache.oscache;

import java.io.InputStream;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.sillycat.easyview.plugin.cache.base.Cache;
import com.sillycat.easyview.plugin.cache.base.CacheProvider;
import com.sillycat.easyview.plugin.cache.base.Timestamper;
import com.sillycat.easyview.plugin.cache.memcached.MemCacheProvider;
import com.sillycat.easyview.plugin.commons.exceptions.CacheException;
import com.sillycat.easyview.plugin.commons.utils.StringUtil;

public class OsCacheProvider implements CacheProvider {

private static final Log log = LogFactory.getLog(OsCacheProvider.class);

public static final String OSCACHE_REFRESH_PERIOD = "oscache.refresh.period";

public static final String OSCACHE_CRON = "oscache.cron";

public static final String OSCACHE_CAPACITY = "oscache.capacity";

public Properties getProperties() throws CacheException {
Properties props = new Properties();
String properties = props.getProperty("oscache.conf",
"oscache.properties");
props.setProperty("oscache.conf", properties);
Resource propertiesResource = new ClassPathResource(properties);
try {
if (!propertiesResource.exists()) {
throw new CacheException("not found '" + properties
+ "' in classpath!");
}
InputStream propertiesInputStream = propertiesResource
.getInputStream();
props.load(propertiesInputStream);
propertiesInputStream.close();
log.info("Loaded '" + properties + "' from "
+ propertiesResource.getFile().getAbsolutePath());
} catch (Exception e) {
throw new CacheException("fail to load/read '" + properties + "'",
e);
}
return props;
}

/**
* 创建一个新的CACHE
*
* @param region
* @param properties
*
* @return
*
* @throws CacheException
*/
public Cache buildCache(String region)
throws CacheException {
Properties properties = this.getProperties();
String refreshPeriod = properties.getProperty(OSCACHE_REFRESH_PERIOD);
int intRefeshPeriod = 100000;
if (StringUtil.isNotBlank(refreshPeriod)) {
// 刷新间隔
intRefeshPeriod = Integer.parseInt(refreshPeriod);
}
String cron = properties.getProperty(OSCACHE_CRON);
// 得到实际的新的CACHE
final OSCache cache = new OSCache(intRefeshPeriod, cron, region);

int capacity = 100;
String capacityStr = properties.getProperty(OSCACHE_CAPACITY);
if (StringUtil.isNotBlank(capacityStr)) {
// 容量
capacity = Integer.valueOf(capacityStr).intValue();
}
cache.setCacheCapacity(capacity);
return cache;
}

public long nextTimestamp() {
return Timestamper.next();
}

public void start() throws CacheException {
}

public void stop() {
}

}

oscache.properties文件是oscache的配置文件，可以配置更多的参数，可以参考OSCACHE官方文档：

oscache.refresh.period=100000
#oscache.cron=
oscache.capacity=100