缓存工厂-CacheManager

记录下项目中用到的缓存的功能，个人感觉这种实现方式还是挺不错的，该实现方式是通过结合spring的IOC容器进行bean管理。

1. 缓存类型配置（这里实现了两种memcached和redis），因为是结合spring使用，所以这个类型配置就可以像数据库连接源那样在properties文件中进行配置，在config.properties配置文件中的memcached配置如下：

#缓存类型
cache.provinder=memcached
#缓存服务器地址和端口
cache.addresses=172.16.1.114:11211
#连接池大小
cache.poolsize=1

2. 缓存接口方法定义，接口中的方法个数可根据实际情况进行添加或删减：

public interface CacheManager {
/**
* 保存键值并指定存储时长，单位秒。
* @param key
* @param value
* @param duration
* @return
*/
void set(String key, String value, int duration);

/**
* 保存键值并指定存储时长和时长单位
* @param key
* @param value
* @param duration
* @param unit
* @return
*/
void set(String key, String value, int duration, TimeUnit unit);

/**
* 永久保存键值
* @param key
* @param value
* @return
*/
void set(String key, String value);

/**
* 根据键获取值
* @param key
* @return null表示没有找到
*/
String get(String key);

/**
* 根据键删除对应键值对
* @param key
* @return
*/
void delete(String key);

/**
* 获取一个计数器，增加相应的值并返回
* @param counter			计数器键名
* @param incrBy			增加的值
* @param defaultValue		计数器默认初始值
* @return
*/
long incrementAndGet(String counter, long incrBy, long defaultValue);

/**
* 获取一个计数器，减少相应的值并返回
* @param counter			计数器键名
* @param decrBy			减少的值
* @param defaultValue		计数器默认初始值
* @return
*/
long decrementAndGet(String counter, long decrBy, long defaultValue);

/**
* 关掉链接，释放资源
*/
void shutdown();
}

2. 缓存工厂类实现

public class CacheManagerFactoryBean implements FactoryBean<CacheManager>{
private Logger log = LoggerFactory.getLogger(CacheManagerFactoryBean.class);
private String provinder;
private String addresses;
private int poolsize;
private CacheManager cm;

public CacheManager getObject() throws Exception {
if("memcached".equals(provinder)){
addresses = addresses.replaceAll("(,\\s*|\\s+)", " ");
cm = new MemcachedCacheManager(addresses, poolsize);
return cm;
}else if("redis".equals(provinder)){
cm = new RedisCacheManager(addresses, poolsize);
return cm;
}else{
throw new Exception("缓存服务器提供商不正确，请设置config.properties中的cache.provinder，值为memcached或redis");
}
}

public void shutdown(){
log.info("shutdown cache manager.");
cm.shutdown();
}

public Class<?> getObjectType() {
return CacheManager.class;
}

public boolean isSingleton() {
return true;
}

public String getAddresses() {
return addresses;
}

public void setAddresses(String addresses) {
this.addresses = addresses;
}

public int getPoolsize() {
return poolsize;
}

public void setPoolsize(int poolsize) {
this.poolsize = poolsize;
}

public String getProvinder() {
return provinder;
}

public void setProvinder(String provinder) {
this.provinder = provinder;
}

}

3. memcached的实现

import java.io.IOException;

import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.utils.AddrUtil;

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

public class MemcachedCacheManager implements CacheManager {

private Logger log = LoggerFactory.getLogger(MemcachedCacheManager.class);
private MemcachedClient client;

public MemcachedCacheManager(String addresses, int poolsize){
MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(addresses));
builder.setConnectionPoolSize(poolsize);
try {
client = builder.build();
} catch (IOException e) {
log.error("failed to build memcached client params:");
log.error("[addresses:{}, poolsize:{}]", new Object[]{addresses, poolsize});
log.error("failed to build memcached client details:", e);
throw new RuntimeException(e);
}
}

public void delete(String key){
try {
client.delete(key);
} catch(Exception e){
log.error("memcached delete failed params:");
log.error("[key:{}]", new Object[]{key});
log.error("memcahced delete failed details:", e);
throw new RuntimeException(e);
}
}

public String get(String key){
try {
return client.get(key);
} catch(Exception e){
log.error("memcached get failed params:");
log.error("[key:{}]", new Object[]{key});
log.error("memcahced get failed details:", e);
throw new RuntimeException(e);
}

}

public void set(String key, String value){
set(key, value, 0);
}

public void set(String key, String value, int duration) {
try {
client.set(key, duration, value);
} catch(Exception e){
log.error("memcached set failed params:");
log.error("[key:{}, value:{}, duration:{}]", new Object[]{key, value, duration});
log.error("memcached set failed details:", e);
throw new RuntimeException(e);
}
}

public void set(String key, String value, int duration, TimeUnit unit) {
set(key, value, duration*unit.getValue());
}

public long incrementAndGet(String counter, long incrBy,
long defaultValue) {
try {
return client.incr(counter, incrBy, defaultValue);
} catch(Exception e){
log.error("memcached incr failed params:");
log.error("[counter:{}, incrBy:{}, defaultValue:{}]", new Object[]{counter, incrBy, defaultValue});
log.error("memcached incr failed details:", e);
throw new RuntimeException(e);
}
}

public long decrementAndGet(String counter, long decrBy,
long defaultValue) {
try {
return client.decr(counter, decrBy, defaultValue);
} catch(Exception e){
log.error("memcached decr failed params:");
log.error("[counter:{}, decrBy:{}, defaultValue:{}]", new Object[]{counter, decrBy, defaultValue});
log.error("memcached decr failed details:", e);
throw new RuntimeException(e);
}
}

public void shutdown() {
try {
client.shutdown();
} catch (IOException e) {
log.error("failed to shutdown memcached client.", e);
}
}
}

4. redis的实现

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;

public class RedisCacheManager implements CacheManager {

private Logger log = LoggerFactory.getLogger(RedisCacheManager.class);

private JedisPool pool;

public RedisCacheManager(String addresses, int poolsize){
try{
String host = addresses.split(":")[0];
String port = addresses.split(":")[1];
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(poolsize);
pool = new JedisPool(config, host, Integer.valueOf(port));
}catch(Exception e){
log.error("failed to build redis client params:");
log.error("[addresses:{}, poolsize:{}]", new Object[]{addresses, poolsize});
log.error("failed to build redis client details:", e);
throw new RuntimeException(e);
}
}

public String get(String key)  {
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
String value = jedis.get(key);
return value;
}catch(Exception e){
// jedis 操作失败把无效的jedis 实例返回给池做销毁处理
success = false;
pool.returnBrokenResource(jedis);
log.error("redis get failed params:");
log.error("[key:{}]", new Object[]{key});
log.error("redis get failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
// jedis 操作成功，把jedis返回给池，得以重用
pool.returnResource(jedis);
}
}
}

public void set(String key, String value){
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
jedis.set(key, value);
}catch(Exception e){
success = false;
pool.returnBrokenResource(jedis);
log.error("redis set failed params:");
log.error("[key:{}, value:{}]", new Object[]{key, value});
log.error("redis set failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
pool.returnResource(jedis);
}
}
}

public void set(String key, String value, int duration){
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
Transaction tx = jedis.multi();
tx.set(key, value);
tx.expire(key, duration);
tx.exec();
}catch(Exception e){
success = false;
pool.returnBrokenResource(jedis);
log.error("redis set failed params:");
log.error("[key:{}, value:{}, duration:{}]", new Object[]{key, value, duration});
log.error("redis set failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
pool.returnResource(jedis);
}
}
}

public void set(String key, String value, int duration, TimeUnit unit) {
set(key, value, duration*unit.getValue());
}

public void delete(String key){
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
jedis.del(key);
}catch(Exception e){
success = false;
pool.returnBrokenResource(jedis);
log.error("redis delete failed params:");
log.error("[key:{}]", new Object[]{key});
log.error("redis delete failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
pool.returnResource(jedis);
}
}
}

public long incrementAndGet(String counter, long incrBy, long defaultValue) {
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
long count = jedis.incrBy(counter, incrBy);
return count;
}catch(Exception e){
success = false;
pool.returnBrokenResource(jedis);
log.error("redis incr failed params:");
log.error("[counter:{}, incrBy:{}, defaultValue:{}]", new Object[]{counter, incrBy, defaultValue});
log.error("redis incr failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
pool.returnResource(jedis);
}
}
}

public long decrementAndGet(String counter, long decrBy, long defaultValue) {
Jedis jedis = null;
boolean success = true;
try{
jedis = pool.getResource();
long count = jedis.decrBy(counter, decrBy);
return count;
}catch(Exception e){
success = false;
pool.returnBrokenResource(jedis);
log.error("redis decr failed params:");
log.error("[counter:{}, incrBy:{}, defaultValue:{}]", new Object[]{counter, decrBy, defaultValue});
log.error("redis decr failed details:", e);
throw new RuntimeException(e);
}finally{
if(success){
pool.returnResource(jedis);
}
}
}

public void shutdown() {
try{
pool.destroy();
}catch(Exception e){
log.error("failed to shutdown redis client.", e);
}
}
}

还可以添加其他的缓存实现，然后在缓存工厂类里面同步加上创建方式就可以了

5. spring中配置缓存工厂实体bean的生成

<bean id="cacheManager" class="com.lutongnet.game.apiserver.cache.CacheManagerFactoryBean" destroy-method="shutdown">
<property name="provinder" value="${cache.provinder}"></property>
<property name="addresses" value="${cache.addresses}"></property>
<property name="poolsize" value="${cache.poolsize}"></property>
</bean>

这样在其他地方就可以通过cacheManager这个实体bean去使用缓存的功能了