Redis实现缓存添加,更新和删除的方法有很多.
1:较为笨拙的方法,也是最稳定的方法,也是一些自动化缓存更新的原理但是代码就多了点,在需要用到缓存的地方,去判断,
先从缓存取,取不到,去数据库查找,找到返回该数据,并写入缓存
2:使用aop的思想,在需要用到缓存的地方左上标识(用注解实现即可,方法很多),剩下的原理同上,这是个一劳永逸的过程
3:就是这篇文章要讲的:使用spring自带的Cacheable注解处理Redis缓存,以下为具体的细节描述
1、引入依赖：
<!-- springboot整合redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、在配置文件中配置 Redis 源：
# redis
########################################################
###REDIS (RedisProperties) redis基本配置
########################################################
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器IP
spring.redis.host=127.0.0.1
# Redis密码（默认为空）
spring.redis.password=
# Redis端口号
spring.redis.port=6379
# 连接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000
########################################################
###REDIS (RedisProperties) redis线程池设置
########################################################
# 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
spring.redis.pool.max-idle=8
# 控制一个pool最少有多少个状态为idle(空闲的)的jedis实例，默认值也是0。
spring.redis.pool.min-idle=2
# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
spring.redis.pool.max-active=20
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
spring.redis.pool.max-wait=3000
#默认生命周期30天（单位：s秒）
spring.redis.defaultExpiration=2592000
#服务器上下文路径
spring.redis.contextPath=contextPath
3、RedisConfig配置类：
package com.mobile.mobilemap.manage.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.*;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.lang.reflect.Method;
/**
* 继承CachingConfigurerSupport，重写CacheManager方法。
*/
@Configuration
@EnableCaching // (缓存支持)
public class RedisConfig extends CachingConfigurerSupport {
private Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 注入 RedisConnectionFactory
*/
@Autowired
RedisConnectionFactory redisConnectionFactory;
/**
* 指定key的生成策略
*
* @return KeyGenerator
*/
@Bean
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
String[] value = new String[1];
Cacheable cacheable = method.getAnnotation(Cacheable.class);
if (cacheable != null) {
value = cacheable.value();
}
CachePut cachePut = method.getAnnotation(CachePut.class);
if (cachePut != null) {
value = cachePut.value();
}
CacheEvict cacheEvict = method.getAnnotation(CacheEvict.class);
if (cacheEvict != null) {
value = cacheEvict.value();
}
sb.append(value[0]);
// 获取参数值
for (Object obj : params) {
sb.append(":" + obj.toString());
}
return sb.toString();
}
};
}
/**
* 实例化 CacheManager 对象，指定使用RedisCacheManager作缓存管理
*
* @return CacheManager
*/
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
// 设置缓存过期时间（单位:秒），60秒
rcm.setDefaultExpiration(600);
return rcm;
}
/**
* 实例化 RedisTemplate 对象
*
* @return RedisTemplate
*/
@Bean
// public RedisTemplate<String, Object> functionDomainRedisTemplate() {
// 方法名为 redisTemplate ，key才不会乱码
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
initDomainRedisTemplate(redisTemplate);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 设置数据存入 redis 的序列化方式 </br>
* redisTemplate 序列化默认使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
*
* @param redisTemplate
*/
private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
// 使用Jackson2JsonRedisSerialize 替换默认序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
redisTemplate.setKeySerializer(new StringRedisSerializer());
// value乱码问题：Jackson2JsonRedisSerializer
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
}
/**
* redis数据操作异常处理 这里的处理：在日志中打印出错误信息，但是放行
* 保证redis服务器出现连接等问题的时候不影响程序的正常运行，使得能够出问题时不用缓存
*
* @return
*/
@Bean
@Override
public CacheErrorHandler errorHandler() {
CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
logger.error("redis异常：key=[{}]", key, e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
logger.error("redis异常：key=[{}]", key, e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
logger.error("redis异常：key=[{}]", key, e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
logger.error("redis异常：", e);
}
};
return cacheErrorHandler;
}
/**
* 实例化 ValueOperations 对象,可以使用 String 操作
*
* @param redisTemplate
* @return
*/
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
/**
* 实例化 HashOperations 对象,可以使用 Hash 类型操作
*
* @param redisTemplate
* @return
*/
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
/**
* 实例化 ListOperations 对象,可以使用 List 操作
*
* @param redisTemplate
* @return
*/
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
/**
* 实例化 SetOperations 对象,可以使用 Set 操作
*
* @param redisTemplate
* @return
*/
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
/**
* 实例化 ZSetOperations 对象,可以使用 ZSet 操作
*
* @param redisTemplate
* @return
*/
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
}
4、使用例子：放到service层上：
@Override
@Cacheable(value="ComplainServiceImpl",key="'getComplainList'.concat(#complain.startTime.toString()).concat(#complain.endTime.toString())", unless = "#result eq null")
public List<BcomplainOutDTO> getComplainList(CalendarInDTO complain) {
// String key = complain.getStartTime() + "," + complain.getEndTime();
// List<BcomplainOutDTO> list = redisTemplate.opsForValue().get(key);
// System.out.println("从缓存中获取 = " + list);
// if (redisTemplate.hasKey(key)) {
//
// System.out.println("==== 从缓存中获取了投诉数据！ ====");
// return list;
// }
// list = complainMapper.getComplainList(complain);
//
// // 缓存100秒
// redisTemplate.opsForValue().set(key, list, 100, TimeUnit.SECONDS);
//
// return list;
return complainMapper.getComplainList(complain);
}
放到dao层上：
@Cacheable(value="getWorkDetailPhotos",key="'getWorkDetailPhotos'.concat(#root.args[0])")
List<String> getWorkDetailPhotos(Integer workId);
缓存的清除：如果我们缓存的实体更新了，怎么办？不能够get的还是旧的东西。这时候就需要强制清除相关联的缓存了。方法就是提供一个空的接口方法，在该方法上添加@CacheEvict的注解，如下：
@CacheEvict(value = "workDetailV150", allEntries=true)
public void evictWorkDetailCache(){
}
5、注意事项:
1)、redis和mysql数据的同步，代码级别大致可以这样做：
2)、读: 读redis->没有，读mysql->把mysql数据写回redis
3)、写: 写mysql->成功，写redis
4)、特别注意的是这里的注入，由于之前配置了redisTemplate及其子类，故需要使用@Resource注解进行！
6、RedisTemplate中定义了对5种数据结构操作：
1)、redisTemplate.opsForValue();//操作字符串
2)、redisTemplate.opsForHash();//操作hash
3)、redisTemplate.opsForList();//操作list
4)、redisTemplate.opsForSet();//操作set
5)、redisTemplate.opsForZSet();//操作有序set
7、Cacheable注解key的说明
这个地方主要简单说明一下3个要素：1.字符串、2.接口参数、3.环境参数，以及一个函数
字符串很好说了用单引号括起来就可以了。
接口参数直接用#加参数名，如果是参数内的属性那么继续用.串联接好了。
环境参数：
属性名称 | 描述 | 示例 |
methodName | 当前方法名 | root.methodName |
method | 当前方法 | root.method.name |
target | 当前被调用的对象 | root.target |
targetClass | 当前被调用的对象的class | root.targetClass |
args | 当前方法参数组成的数组 | root.args[0] |
caches | 当前被调用的方法使用的Cache | root.caches[0].name |
