spring cache redis

zoukankan html css js c++ java

spring cache redis

一、使用开源包（spring-data-redis）

1、引入jar包

<dependency>
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-redis</artifactId>
     <version>1.8.11.RELEASE</version>
</dependency>

2、配置Spring xml文件



<bean name="redisTemplate" class=" RedisTemplate">
<property name="redisPool" ref="redisPool"/>
<property name="keySerializer" ref="org.springframework.data.redis.serializer.StringRedisSerializer"></property>
<property name="hashKeySerializer" ref="org.springframework.data.redis.serializer.StringRedisSerializer"></property>
</bean>

<bean name="cacheManager" class="com.config.ExtendedRedisCacheManager">
    <constructor-arg name="redisOperations" ref="redisTemplate"/>
    <constructor-arg name="cacheNames">
        <set>
            <value>default</value>
            <value>test1</value>
        </set>
    </constructor-arg>
    
<property name="defaultCacheName" value="default"/>
    
<property name="loadRemoteCachesOnStartup" value="true"/>
    
<property name="usePrefix" value="true"/>
    
<property name="cachePrefix">
        <bean class="org.springframework.data.redis.cache.DefaultRedisCachePrefix">
            <constructor-arg name="delimiter" value=":"/>
        </bean>
    </property>
    
<property name="separator" value="#"/>
    
<property name="defaultExpiration" value="60"/>
</bean>

ps：redis配置继续用现有的

3、配置redis挂掉，直接访问数据库（redis挂掉，最好配置预警）

@Configuration
@EnableCaching
public class AppCacheConfigurer extends CachingConfigurerSupport {
    private Logger logger = LoggerFactory.getLogger(AppCacheConfigurer.class);

    public class AppCacheErrorHandler implements CacheErrorHandler {
        @Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object o) {
            if (e instanceof JedisConnectionException || e instanceof RedisConnectionFailureException) {
                logger.warn("redis has lose connection:", e);
                return;
            }
            throw e;
        }

        @Override
public void handleCachePutError(RuntimeException e, Cache cache, Object o, Object o1) {
            if (e instanceof JedisConnectionException || e instanceof RedisConnectionFailureException) {
                logger.warn("redis has lose connection:", e);
                return;
            }
            throw e;
        }

        @Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object o) {
            throw e;
        }

        @Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
            throw e;
        }
    }

    @Override
public CacheErrorHandler errorHandler() {
        return new AppCacheErrorHandler();
    }
}

5、配置独立设置过期时间，重写RedisCacheManager

public class ExtendedRedisCacheManager extends RedisCacheManager {

    private static final Logger logger = Logger.getLogger(ExtendedRedisCacheManager.class);

    private static final ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");

    private static final Pattern pattern = Pattern.compile("[+\-*/%]");

    private String defaultCacheName;

    private char separator = '#';

    public ExtendedRedisCacheManager(RedisOperations redisOperations) {
        this(redisOperations, Collections.<String>emptyList());
    }

    public ExtendedRedisCacheManager(RedisOperations redisOperations, Collection<String> cacheNames) {
        super(redisOperations, cacheNames);
    }

    @Override
public Cache getCache(String name) {
        // try to get cache by name
RedisCache cache = (RedisCache) super.getCache(name);
        if (cache != null) {
            return cache;
        }

        // there's no cache which has given name
// find separator in cache name
int index = name.lastIndexOf(getSeparator());
        if (index < 0) {
            return null;
        }

        // split name by the separator
String cacheName = name.substring(0, index);
        if(StringUtils.isBlank(cacheName)){
            cacheName = defaultCacheName;
        }
        cache = (RedisCache) super.getCache(cacheName);
        if (cache == null) {
            return null;
        }

        // get expiration from name
Long expiration = getExpiration(name, index);
        if (expiration == null || expiration < 0) {
            logger.warn("Default expiration time will be used for cache '{}' because cannot parse '{}', cacheName : " + cacheName + ", name : " + name);
            return cache;
        }

        return new RedisCache(cacheName, (isUsePrefix() ? getCachePrefix().prefix(cacheName) : null), getRedisOperations(), expiration);
    }

    public char getSeparator() {
        return separator;
    }

    /**
* Char that separates cache name and expiration time, default: #.
*
* @param separator
*/
public void setSeparator(char separator) {
        this.separator = separator;
    }

    private Long getExpiration(final String name, final int separatorIndex) {
        Long expiration = null;
        String expirationAsString = name.substring(separatorIndex + 1);
        try {
            // calculate expiration, support arithmetic expressions.
if(pattern.matcher(expirationAsString).find()){
                expiration = (long) Double.parseDouble(scriptEngine.eval(expirationAsString).toString());
            }else{
                expiration = Long.parseLong(expirationAsString);
            }
        } catch (NumberFormatException ex) {
            logger.error(String.format("Cannnot separate expiration time from cache: '%s'", name), ex);
        } catch (ScriptException e) {
            logger.error(String.format("Cannnot separate expiration time from cache: '%s'", name), e);
        }

        return expiration;
    }

    @Override
public void setUsePrefix(boolean usePrefix) {
        super.setUsePrefix(usePrefix);
    }

    @Override
public void setCachePrefix(RedisCachePrefix cachePrefix) {
        super.setCachePrefix(cachePrefix);
    }

    public void setDefaultCacheName(String defaultCacheName) {
        this.defaultCacheName = defaultCacheName;
    }
}

6、通过注解设置缓存

@Cacheable(value = "test1#60",key = "#p0")//Cacheable会判断key是否存在，增加redis缓存，设置为60秒，key为test1:xxx

@CachePut(cacheNames="test1#60",key = "#p0")//CachePut不会判断key是否存在，直接覆盖，增加redis缓存，设置为60秒，key为test1:xxx，它每次都会触发真实方法的调用

@CacheEvict(value = "test1",key = "#p1")//删除缓存

其他缓存注解，参考spring cache注解相关定义

二、解决现有系统版本不兼容问题

1、线上spring版本为：3.2.9.RELEASE

解决兼容redis挂掉的spring版本为4.1以上

  适用于现在系统的配置如下

2、引入jar包

<dependency>
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-redis</artifactId>
     <version>1.3.4.RELEASE</version>
</dependency>

PS：低版本主要为了兼容现在的spring版本和jedis版本

3、实现自己的Spring cache，主要是为了兼容现有redis配置（现有系统redis的实现是自己实现的）

public class ExtendRedisCache implements Cache {

    private static final Logger LOG = LoggerFactory.getLogger(ExtendRedisCache.class);

    /**
* Redis
*/
private RedisTemplate redisTemplate;

    /**
* 缓存名称
*/
private String name;

    /**
* 默认超时时间
*/
private int timeout;

    @Override
public String getName() {
        return this.name;
    }

    @Override
public Object getNativeCache() {
        return this.redisTemplate;
    }

    @Override
public ValueWrapper get(Object key) {

        if (StringUtils.isEmpty(key)) {
            return null;
        }
        Jedis jedis = null;
        try{
            jedis = redisTemplate.getRedisPool().getResource();
            //键
final String finalKey = getKey(key);

            if(StringUtils.isEmpty(finalKey)){
                return null;
            }

            byte[] value = jedis.get(finalKey.getBytes());
            if (value == null) {
                return null;
            }

            Object object = SerializableUtil.unserialize(value);
            return (object != null ? new SimpleValueWrapper(object) : null);

        }catch (Exception e){
            LOG.error("redis has lose connection:",e);
            return null;
        }finally {
            if (null != jedis) {
                jedis.close();
            }
        }

    }

    /**
* 获取redis缓存键
*
* @param key
* @return
*/
private String getKey(Object key) {
        //键
final String finalKey;

        if (key instanceof String) {
            finalKey = this.name + ":" + (String) key;
        } else {
            finalKey = this.name + ":" + key.toString();
        }

        return finalKey;
    }

    @Override
public void put(Object key, Object value) {

        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
            return;
        }

        Jedis jedis = null;
        try{
            //键
final String finalKey = getKey(key);

            if(!StringUtils.isEmpty(finalKey)){
                jedis = redisTemplate.getRedisPool().getResource();
                redisTemplate.set(finalKey.getBytes(), SerializableUtil.serialize(value));
                jedis.expire(finalKey.getBytes(),timeout);
            }
        }catch (Exception e){
            LOG.error("redis has lose connection:",e);
        }finally {
            if (null != jedis) {
                jedis.close();
            }
        }

    }

    /*
* 根据Key 删除缓存
*/
@Override
public void evict(Object key) {
        if (null != key) {
            try{
                final String finalKey = getKey(key);

                if (!StringUtils.isEmpty(finalKey)) {
                    redisTemplate.del(finalKey.getBytes());
                }
            }catch (Exception e){
                LOG.error("redis has lose connection:",e);
            }
        }
    }

    /*
* 清除系统缓存
*/
@Override
public void clear() {
        //线上不允许删除所有缓存
}

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

4、添加spring xml配置

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:cache="http://www.springframework.org/schema/cache"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/cache
http://www.springframework.org/schema/cache/spring-cache.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd ">

PS:添加红色标注地方


<cache:annotation-driven/>


<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    <property name="caches">
        <set>
            <bean class="ExtendRedisCache">

                <property name="redisTemplate" ref="redisTemplate" /> //现有系统的redisTemplate

                <property name="name" value="test1" /> //缓存名（结合key）
                <property name="timeout" value="60" /> //过期时间
            </bean>
        </set>
    </property>
</bean>

5、通过注解设置缓存

@Cacheable(value = "test1",key = "#p0")//Cacheable会判断key是否存在，增加redis缓存，key为test1:xxx，这里过期时间在xml里配置

@CachePut(cacheNames="test1",key = "#p0")//CachePut不会判断key是否存在，直接覆盖，它每次都会触发真实方法的调用，增加redis缓存，key为test1:xxx，，这里过期时间在xml里配置

@CacheEvict(value = "test1",key = "#p1")//删除缓存

其他缓存注解，参考spring cache注解相关定义

查看全文

相关阅读:
关于代码片段
 感谢visual studio(git插件)救我一命
 SRX一些配置命令
 .NET Core Policy和Claim
.NET Core Identity 用户管理和策略
 .NET Core基础配置、注册服务、中间件、ViewComponent、DbContext
table非常细边框
 js数字转大写金额
 蓝牙开发
 Laravel artisan 命令

原文地址：https://www.cnblogs.com/haifg/p/9711375.html