spring cache 集成 cacheCloud redis
最近研究了一下cacheCloud,简单的环境搭建了一下,觉得非常厉害,这里就把一些集成客户端的一些操作记录下来,方便以后查看
- pom.xml文件配置
<dependency>
<groupId>com.sohu.tvgroupId>
<artifactId>cachecloud-jedisartifactId>
<version>${cachecloud-jedis}version>
dependency>
<dependency>
<groupId>com.sohu.tvgroupId>
<artifactId>cachecloud-open-client-redisartifactId>
<version>${cachecloud-open-client-basic}version>
<exclusions>
<exclusion>
<artifactId>jedisartifactId>
<groupId>redis.clientsgroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<version>${springframework.version}version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.16version>
dependency>- 客户端代码
接口类 , 这里只定义了一些常用的操作,具体实现我就不贴了,这一块可以根据你们自己的业务去做实现
import java.util.List;
import java.util.Map;
/** * 缓存接口定义 * * @author Liukx * @create 2017-05-17 15:40 * @email [email protected] **/
public interface ICacheClient {
/** * 将一个数组key进行原子性相减 * * @param key 键 * @param num 减去的值 * @return */
Long decrby(String key, long num);
/** * 将一个原子性的数值即你想那个累加 * @param key 键 * @param num 累加的值 * @return */
Long incrby(String key, long num);
/** * 判断key是否存在 * * @param key * @return */
boolean exsit(String key);
/** * 设置一个键的有效时长 * * @param key 键 * @param seconds 有效时长 单位:秒 */
boolean expire(String key, int seconds);
/** * 获取一个key的有效时长 * * @param key * @return */
Long ttl(String key);
/** * 添加一个普通值 * * @param key 键 * @param value 值 */
void set(String key, T value);
/** * 添加一个list的值 * * @param key 键 * @param list 值 */
void setList(String key, List list);
/** * 添加一个map的值 * @param key * @param map * @param */
void setMap(String key, Map map);
/** * 添加一个值,并为它设置一个有效时间 * * @param key 键 * @param value 值 * @param validTime 有效时间 1秒=1000 -1 永久有效 */
void set(String key, Object value, int validTime);
/** * 根据键获取值 * * @param key 键 - 标识 * @return */
T get(String key, Class t);
/** * 获取list结果集 * @param key * @param * @return */
List getList(String key, Class clazz);
/** * 获取map结果集 * @param key * @param * @return */
Map getMap(String key, Class clazz);
/** * 设置一个值到集合中,如果存在则返回key存在 则返回false * * @param key 键 * @param value 值 * @return */
boolean setNX(String key, Object value);
/** * 根据键删除一个值 * * @param key 键 */
void delete(String key);
/** * 带锁的数据操作,例如当设置一个setnx发现键已经存在,则超时时间的范围内阻塞尝试,直到锁被释放,如果过了超时时间则表示失败 * * @param key key * @param value 值 * @param timeout 超时时间 单位秒 * @return */
boolean tryLock(String key, Object value, int timeout);
/** * 删除带锁的数据 * * @param key 带锁的key */
void unLock(String key);
/** * 通过key 和offset 从指定的位置开始将原先value替换
* 下标从0开始,offset表示从offset下标开始替换
* 如果替换的字符串长度过小则会这样
* example:
* value : [email protected]
* str : abc
* 从下标7开始替换 则结果为
* RES : bigsea.abc.cn
* @param key * @param value * @param offset 下标位置 * @return 返回替换后 value 的长度 */
Long setRange(String key, String value, int offset);
/** * 通过下标 和key 获取指定下标位置的 value
* @param key * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取 * @param endOffset * @return 如果没有返回null */
String getRange(String key, int startOffset, int endOffset);
/** * 通过批量的key获取批量的value
* @param keys string数组 也可以是一个key * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空 */
List mget(String... keys);
/** * 批量的设置key:value,可以一个
* example:
* obj.mset(new String[]{"key2","value1","key2","value2"})
* @param keysvalues * @return 成功返回OK 失败 异常 返回 null * */
String mset(String... keysvalues);
/** * 批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚
* example:
* obj.msetnx(new String[]{"key2","value1","key2","value2"})
* @param keysvalues * @return 成功返回1 失败返回0 */
Long msetnx(String... keysvalues);
/** * 通过key给Hash Field设置指定的值,如果key不存在,则先创建
* @param key * @param field 字段 * @param value * @return 如果存在返回0 异常返回null */
Long hset(String key, String field, String value);
/** * Sets field in the hash stored at key to value * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0
* @param key * @param field * @param value * @return */
public Long hsetnx(String key, String field, String value);
/** * 通过key同时设置 hash的多个field
* @param key * @param hash * @return 返回OK 异常返回null */
public String hmset(String key, Map hash);
/** * 通过key 和 field 获取指定的 value
* @param key * @param field * @return 没有返回null */
public String hget(String key, String field);
/** * 通过key 和 fields 获取指定的value 如果没有对应的value则返回null
* @param key * @param fields 可以是 一个String 也可以是 String数组 * @return */
public List hmget(String key,String...fields);
/** * 通过key向list头部添加字符串
* @param key * @param strs 可以是一个string 也可以是string数组 * @return 返回list的value个数 */
Long lpush(String key ,String...strs);
/** * 获取指定list * @param key 键 * @param startIndex 开始下标 * @param endIndex 结束下标 -1 代表获取所有 * @return */
List lrange(String key, int startIndex, int endIndex);
/** * 获取所有list * @param key 键 * @return */
List lrange(String key);
String get(String key);
} 然后就是实现Spring的cache接口的类,里面掺杂了一些我们业务相关的代码,你可以不用关注,大概了解意思就行了
import com.elab.cache.ICacheClient;
import com.elab.core.bean.Info;
import com.elab.core.utils.ObjectUtils;
import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
/** 这个类是比较关键的,就是相当于你实现了spring的接口,只要将你的缓存交给spring,让他去做一系列的事情就行了 */
public class SystemCacheManage implements Cache {
@Override
public ValueWrapper putIfAbsent(Object key, Object value) {
return null;
}
/** * Redis */
private ICacheClient cacheClient;
/** * 缓存名称 */
private String name;
/** * 超时时间 */
private int timeout;
/* * (non-Javadoc) * @see org.springframework.cache.Cache#getName() */
@Override
public String getName() {
return this.name;
}
/* * (non-Javadoc) * @see org.springframework.cache.Cache#getNativeCache() */
@Override
public Object getNativeCache() {
return this.cacheClient;
}
/* * (non-Javadoc) * @see org.springframework.cache.Cache#get(java.lang.Object) */
@Override
public ValueWrapper get(Object key) {
if (ObjectUtils.isEmpty(key)) {
return null;
} else {
final String finalKey;
if (key instanceof String) {
finalKey = (String) key;
} else {
finalKey = key.toString();
}
Object object = cacheClient.get(finalKey, Info.class);
return (object != null ? new SimpleValueWrapper(object) : null);
}
}
/* * (non-Javadoc) * @see org.springframework.cache.Cache#get(java.lang.Object, java.lang.Class) */
@SuppressWarnings("unchecked")
@Override
public T get(Object key, Class type) {
if (ObjectUtils.isEmpty(key) || null == type) {
return null;
} else {
final String finalKey;
final Class finalType = type;
if (key instanceof String) {
finalKey = (String) key;
} else {
finalKey = key.toString();
}
final Object object = cacheClient.get(finalKey, type);
if (finalType != null && finalType.isInstance(object) && null != object) {
return (T) object;
} else {
return null;
}
}
}
/* * (non-Javadoc) * @see org.springframework.cache.Cache#put(java.lang.Object, java.lang.Object) */
@Override
public void put(final Object key, final Object value) {
if (ObjectUtils.isEmpty(key) || ObjectUtils.isEmpty(value)) {
return;
} else {
final String finalKey;
if (key instanceof String) {
finalKey = (String) key;
} else {
finalKey = key.toString();
}
if (!ObjectUtils.isEmpty(finalKey)) {
cacheClient.set(finalKey, value, timeout);
}
}
}
/* * 根据Key 删除缓存 */
@Override
public void evict(Object key) {
if (null != key) {
final String finalKey;
if (key instanceof String) {
finalKey = (String) key;
} else {
finalKey = key.toString();
}
if (!com.elab.core.utils.ObjectUtils.isEmpty(finalKey)) {
cacheClient.delete(finalKey);
}
}
}
/* * 清除系统缓存 */
@Override
public void clear() {
// TODO Auto-generated method stub
// redisTemplate.execute(new RedisCallback() {
// public String doInRedis(RedisConnection connection) throws DataAccessException {
// connection.flushDb();
// return "ok";
// }
// });
}
public void setName(String name) {
this.name = name;
}
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public ICacheClient getCacheClient() {
return cacheClient;
}
public void setCacheClient(ICacheClient cacheClient) {
this.cacheClient = cacheClient;
}
} 动态生成redis中的key生成策略,这个有需要就定义,没有需要就不用,我这里是根据类加方法名加参数构成的一个key
import com.alibaba.fastjson.JSON;
import org.springframework.cache.interceptor.KeyGenerator;
import java.lang.reflect.Method;
/** * 默认的缓存key生成策略 * * @author Liukx * @create 2017-11-06 13:38 * @email [email protected] **/
public class DefaultCacheKeyGenerator implements KeyGenerator {
@Override
public Object generate(Object target, Method method, Object... params) {
String className = target.getClass().getSimpleName();
String name = method.getName();
String jsonParams = JSON.toJSONString(params);
String cachekey = className + "_" + name + "_" + jsonParams;
return cachekey;
}
}
异常处理类,这里异常只记录了日志没有做什么特殊的实现
/** * 缓存异常处理 * * @author Liukx * @create 2017-11-06 17:58 * @email [email protected] **/
public class ErrorCacheHandle implements CacheErrorHandler {
Logger logger = LoggerFactory.getLogger(ErrorCacheHandle.class);
public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
logger.error("‖‖‖‖‖‖‖‖‖缓存异常[handleCacheGetError]‖‖‖‖‖‖‖‖‖‖ cache : " + cache.getName() + " \t key : " + key.toString());
}
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
logger.error("‖‖‖‖‖‖‖‖‖缓存异常[handleCachePutError]‖‖‖‖‖‖‖‖‖‖ cache : " + cache.getName() + " \t key : " + key.toString() + "\t value : " + value);
}
public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
logger.error("‖‖‖‖‖‖‖‖‖缓存异常[handleCacheEvictError]‖‖‖‖‖‖‖‖‖‖ cache : " + cache.getName() + " \t key : " + key.toString());
}
public void handleCacheClearError(RuntimeException exception, Cache cache) {
logger.error("‖‖‖‖‖‖‖‖‖缓存异常[handleCacheClearError]‖‖‖‖‖‖‖‖‖‖ cache : " + cache.getName());
}
}接下来就是比较关键的配置文件定义了
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:cache="http://www.springframework.org/schema/cache" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd ">
<bean id="defaultCacheKeyGenerator" class="com.elab.cache.spring.generator.DefaultCacheKeyGenerator"/>
<bean id="errorCacheHandle" class="com.elab.cache.spring.handle.ErrorCacheHandle" />
<cache:annotation-driven error-handler="errorCacheHandle" key-generator="defaultCacheKeyGenerator"/>
<bean id="systemCacheManage" class="com.elab.cache.spring.manage.SystemCacheManage">
<property name="cacheClient" ref="redisStandaloneClient"/>
<property name="timeout" value="300"/>
<property name="name" value="redisClient"/>
bean>
<bean id="simpleCacheManager" class="org.springframework.cache.support.SimpleCacheManager">
<property name="caches" ref="systemCacheManage"/>
bean>
<bean id="cacheManager" class="org.springframework.cache.support.CompositeCacheManager">
<property name="cacheManagers">
<list>
<ref bean="simpleCacheManager"/>
list>
property>
<property name="fallbackToNoOpCache" value="true"/>
bean>
beans>如何测试?
在需要加入缓存的方法上面加入下面注解,需要注意的是
- 第一个参数value 对应的就是配置文件中的systemCacheManage的name给定的值
- 第二个参数就是你自己默认要指定的key,也就是redis中的key,可以是动态的,不填的话,就会调用上面默认的生成key的策略方法DefaultCacheKeyGenerator
- 第三个参数就是当前缓存的方法必须满足condition 中的条件才能被缓存!
// 会从缓存中查询key,如果存在则不会进入该方法,不存在则进入,执行完之后进行缓存
@Cacheable(value = "redisClient", key = "'lkx_test_'+#redisModel.id", condition = "#redisModel.id != null")
//这个注解适用于DML操作的方法,表示每次都会执行该方法,并且缓存结果
@CachePut(value = "redisClient", key = "'lkx_test_'+#redisModel.id")
/** * 清除缓存的注解 * allEntries : 是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存 * beforeInvocation : 是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存 * * @param redisModel * @return */
@CacheEvict(value = "redisClient", key = "'lkx_test_'+#redisModel.id", allEntries = false, beforeInvocation = false)另外这些注解都是需要被扫描到的,所以类上面一定要有spring的扫描注解!!
比如@Service …. 写的不是特别详细,也是大概粗略的研究了下,不是特别深入,如果有不对的地方请指正,不懂的地方也可以提问….