spring cache 集成 cacheCloud redis

其他 2019-02-25 10:24:34 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lkx444368875/article/details/78949619

最近研究了一下cacheCloud,简单的环境搭建了一下,觉得非常厉害,这里就把一些集成客户端的一些操作记录下来,方便以后查看

  1. pom.xml文件配置
<!-- sohu的相关jar包 -->
 <dependency>
          <groupId>com.sohu.tv</groupId>
            <artifactId>cachecloud-jedis</artifactId>
            <version>${cachecloud-jedis}</version>
  </dependency>

<dependency>
            <groupId>com.sohu.tv</groupId>
            <artifactId>cachecloud-open-client-redis</artifactId>
            <version>${cachecloud-open-client-basic}</version>
            <exclusions>
                <exclusion>
                    <artifactId>jedis</artifactId>
                    <groupId>redis.clients</groupId>
                </exclusion>
            </exclusions>
        </dependency>

<!-- spring相关的jar包  我这里的版本是 4.3.7.RELEASE -->
 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
 <!-- 工具 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.16</version>
        </dependency>
  1. 客户端代码
    接口类 , 这里只定义了一些常用的操作,具体实现我就不贴了,这一块可以根据你们自己的业务去做实现
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 值
     */
    <T> void set(String key, T value);

    /**
     * 添加一个list的值
     *
     * @param key   键
     * @param list 值
     */
    <T> void setList(String key, List<T> list);

    /**
     * 添加一个map的值
     * @param key
     * @param map
     * @param <T>
     */
    <T> void setMap(String key, Map<String, T> map);

    /**
     * 添加一个值,并为它设置一个有效时间
     *
     * @param key       键
     * @param value     值
     * @param validTime 有效时间  1秒=1000   -1 永久有效
     */
    void set(String key, Object value, int validTime);

    /**
     * 根据键获取值
     *
     * @param key 键 - 标识
     * @return
     */
    <T>T get(String key, Class t);

    /**
     * 获取list结果集
     * @param key
     * @param <T>
     * @return
     */
    <T> List<T> getList(String key, Class clazz);

    /**
     *  获取map结果集
     * @param key
     * @param <T>
     * @return
     */
    <T> Map<String, T> 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);

    /**
     * <p>通过key 和offset 从指定的位置开始将原先value替换</p>
     * <p>下标从0开始,offset表示从offset下标开始替换</p>
     * <p>如果替换的字符串长度过小则会这样</p>
     * <p>example:</p>
     * <p>value : [email protected]</p>
     * <p>str : abc </p>
     * <P>从下标7开始替换  则结果为</p>
     * <p>RES : bigsea.abc.cn</p>
     * @param key
     * @param value
     * @param offset 下标位置
     * @return 返回替换后  value 的长度
     */
    Long setRange(String key, String value, int offset);

    /**
     * <p>通过下标 和key 获取指定下标位置的 value</p>
     * @param key
     * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取
     * @param endOffset
     * @return 如果没有返回null
     */
    String getRange(String key, int startOffset, int endOffset);

    /**
     * <p>通过批量的key获取批量的value</p>
     * @param keys string数组 也可以是一个key
     * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空
     */
    List<String> mget(String... keys);

    /**
     * <p>批量的设置key:value,可以一个</p>
     * <p>example:</p>
     * <p>  obj.mset(new String[]{"key2","value1","key2","value2"})</p>
     * @param keysvalues
     * @return 成功返回OK 失败 异常 返回 null
     *
     */
    String mset(String... keysvalues);


    /**
     * <p>批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚</p>
     * <p>example:</p>
     * <p>  obj.msetnx(new String[]{"key2","value1","key2","value2"})</p>
     * @param keysvalues
     * @return 成功返回1 失败返回0
     */
    Long msetnx(String... keysvalues);

    /**
     * <p>通过key给Hash Field设置指定的值,如果key不存在,则先创建</p>
     * @param key
     * @param field 字段
     * @param value
     * @return 如果存在返回0 异常返回null
     */
    Long hset(String key, String field, String value);

    /**
     * <p>Sets field in the hash stored at key to value
     * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0</p>
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hsetnx(String key, String field, String value);

    /**
     * <p>通过key同时设置 hash的多个field</p>
     * @param key
     * @param hash
     * @return 返回OK 异常返回null
     */
    public String hmset(String key, Map<String, String> hash);

    /**
     * <p>通过key 和 field 获取指定的 value</p>
     * @param key
     * @param field
     * @return 没有返回null
     */
    public String hget(String key, String field);

    /**
     * <p>通过key 和 fields 获取指定的value 如果没有对应的value则返回null</p>
     * @param key
     * @param fields 可以是 一个String 也可以是 String数组
     * @return
     */
    public List<String> hmget(String key,String...fields);

    /**
     * <p>通过key向list头部添加字符串</p>
     * @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<String> lrange(String key, int startIndex, int endIndex);

    /**
     * 获取所有list
     * @param key 键
     * @return
     */
    List<String> 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> T get(Object key, Class<T> type) {
        if (ObjectUtils.isEmpty(key) || null == type) {
            return null;
        } else {
            final String finalKey;
            final Class<T> 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<String>() {
        // 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());
    }
}

接下来就是比较关键的配置文件定义了

<?xml version="1.0" encoding="UTF-8"?>
<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
    ">
    <!-- 默认生成的缓存key的实现策略 -->
    <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">
      <!-- 这里是cacheCloud的一些代码定义,其实就是它的实现类 -->
        <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>
        <!-- 当value找不到时,是否使用一个null[NoOpCacheManager]代替 -->
        <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 …. 写的不是特别详细,也是大概粗略的研究了下,不是特别深入,如果有不对的地方请指正,不懂的地方也可以提问….

猜你喜欢

转载自blog.csdn.net/lkx444368875/article/details/78949619
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022