redis是现在最主流的缓存利器，但是你的项目中，缓存真正做到了解耦了吗？
背景
最近，项目中遇到一个redis缓存使用的问题，当redis连接不上时，直接导致业务异常。redis不是做为缓存使用吗？当缓存中查询不到，不是应该主动从数据库加载吗？
最后发现是利用RedisTemplate操作缓存，没有进行异常捕捉处理，导致异常抛出影响到业务的正常执行。
那么，你的项目中，缓存操作真的做到了解耦吗？
缓存原理
缓存的使用
目前redis缓存主要有2种使用方式：
方式一：结合Spring Cache使用，通过@Cacheable、@CachePut 、@CacheEvict这3个缓存注解实现缓存控制
方式二：通过RedisTemplate模板方法通过编码控制缓存
代码实战
依赖包：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
缓存连接属性配置：
# Redis_config
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123456
# 根据需要
# 连接超时时间（毫秒）
spring.redis.timeout=10s
# Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
spring.redis.database=0
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1s
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
config配置类
/**
*
* 1、@EnableCaching是为了开启spring cache的缓存注解功能
* 2、继承CachingConfigurerSupport是为了配置spring cache的主键生成策略keyGenerator和cacheManager
* 3、配置RedisTemplate的序列化机制Jackson
* 4、配置spring cache的异常处理类CacheErrorHandler
* @program: wxswj
* @description: redis配置类
* @author: wanli
* @create: 2018-10-09 18:39
**/
@Configuration
@EnableCaching
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig extends CachingConfigurerSupport {
/**
* @return 自定义策略生成的key
* @description 自定义的缓存key的生成策略
* 若想使用这个key 只需要讲注解上keyGenerator的值设置为keyGenerator即可</br>
*/
@Bean
@Override
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuffer sb = new StringBuffer();
sb.append(target.getClass().getName());
sb.append(":"+method.getName());
for (Object obj : params) {
sb.append(":"+obj.toString());
}
return sb.toString();
}
};
}
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
//设置序列化
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);
//配置redisTemplate
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
RedisSerializer stringSerializer = new StringRedisSerializer();
//key序列化
redisTemplate.setKeySerializer(stringSerializer);
//value序列化
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
//Hash key序列化
redisTemplate.setHashKeySerializer(stringSerializer);
//Hash value序列化
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
//缓存管理器
@Bean
public RedisCacheManager cacheManager(LettuceConnectionFactory redisConnectionFactory) {
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);
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.entryTtl(Duration.ofHours(1));
return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)).cacheDefaults(redisCacheConfiguration).build();
}
@Override
@Bean
public CacheErrorHandler errorHandler(){
//CacheErrorHandler cacheErrorHandler = new SimpleCacheErrorHandler();
CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
private Logger logger = LoggerFactory.getLogger(CacheErrorHandler.class);
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object o) {
logger.error("redis 异常：key=[{}]",o,e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object o, Object o1) {
logger.error("redis 异常：key=[{}]",o,e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object o) {
logger.error("redis 异常：key=[{}]",o,e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
logger.error("redis 异常：",e);
}
};
return cacheErrorHandler;
}
}
这里补充说明一下，CacheErrorHandler是Spring Cache里面注解控制缓存的异常处理类，其默认实现是SimpleCacheErrorHandler，里面对异常的处理都是直接抛出。
所以，当redis服务器出现连接异常或操作失败时，会影响后续的业务代码执行。
public class SimpleCacheErrorHandler implements CacheErrorHandler {
public SimpleCacheErrorHandler() {
}
public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
throw exception;
}
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, @Nullable Object value) {
throw exception;
}
public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
throw exception;
}
public void handleCacheClearError(RuntimeException exception, Cache cache) {
throw exception;
}
}需要缓存的实体：
@Data
public class Person {
private Integer id;
private String name;
private Integer age;
}
通过@Cacheable控制读操作的缓存
/**
* 通过注解@Cacheable中的value相当于声明一个存放缓存的文件夹，可以理解为 "get:"+keyGenerator
* keyGenerator = "#id"
* @param id
* @return
*/
@Cacheable(value = "person",keyGenerator = "keyGenerator")
@Override
public Person get(Integer id){
log.info("未命中缓存，从数据库查询");
Person person = new Person();
person.setId(id);
person.setName("laowan");
person.setAge(25);
return person;
}
通过RedisTemplate封装缓存操作服务类：
/**
* @program: redis
* @description: 缓存工具类
* @author: wanli
* @create: 2020-05-12 09:42
**/
public interface CacheService {
/**
* 直接设置缓存
* @param key
* @param value
* @return
*/
boolean setCache(String key,Object value);
/**
* 设置缓存并设置过期时间
* @param key
* @param value
* @param timeout
* @param timeUnit
* @return
*/
boolean setCacheExpire(String key, Object value, long timeout, TimeUnit timeUnit);
/**
* 不设置回调返回的获取方法
* @param key
* @param clazz
* @param <T>
* @return
*/
<T> T getCache(String key,Class<T> clazz);
/**
* 传递回调方法，重设缓存时设置过期时间
* @param key 键
* @return 值
*/
<T> T getCache(String key,Class<T> clazz,long timeout, TimeUnit timeUnit,CacheCallBack<T,String> callBack);
<T> T getCache(String key,Class<T> clazz,CacheCallBack<T,String> callBack);
/**
* 删除缓存
* @param key
* @return
*/
boolean deleteCache(String key);
}
从缓存获取为空的回调方法：
/**
* @program: redis
* @description: 缓存回调接口
* @author: wanli
* @create: 2020-05-12 09:43
**/
public interface CacheCallBack <O,I> {
O execute(I input);
}
/**
* @program: redis
* @description: 缓存接口实现类
* @author: wanli
* @create: 2020-05-12 09:50
**/
@Slf4j
@Service
public class CacheServiceImpl implements CacheService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Override
public boolean setCache(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean setCacheExpire(String key, Object value, long timeout, TimeUnit timeUnit) {
try {
if(timeout>0){
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}else{
this.setCache(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public <T> T getCache(String key, Class<T> clazz) {
T o = null;
try {
if(key!=null){
Object result = redisTemplate.opsForValue().get(key);
o = result!=null?(T)result:null;
}
}catch (Exception e) {
e.printStackTrace();
}
return o;
}
@Override
public <T> T getCache(String key, Class<T> clazz, CacheCallBack<T, String> callBack) {
T o = null;
try {
o = this.getCache(key,clazz);
if(o==null){
log.info("未命中缓存，执行CacheCallBack回调函数");
o = callBack.execute(key);
if(o!=null){
this.setCache(key,o);
}
}
}catch (Exception e) {
e.printStackTrace();
}
return o;
}
@Override
public <T> T getCache(String key, Class<T> clazz, long timeout, TimeUnit timeUnit, CacheCallBack<T, String> callBack) {
T o = null;
try {
o = this.getCache(key,clazz);
if(o==null){
log.info("未命中缓存，执行CacheCallBack回调函数");
o = callBack.execute(key);
if(o!=null){
this.setCacheExpire(key,o,timeout,timeUnit);
}
}
}catch (Exception e) {
e.printStackTrace();
}
return o;
}
@Override
public boolean deleteCache(String key) {
try {
redisTemplate.delete(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
}
通过封装的服务类CacheServiceImpl控制缓存:
private String person_cache_key="person:get:";
@Autowired
CacheService cacheService;
/**
* 硬编码实现查询缓存——》判空——》然后查询数据库——》判空——》更新缓存
* @param id
* @return
*/
@Override
public Person getPerson(Integer id){
String key = person_cache_key + id;
Person person = cacheService.getCache(key,Person.class);
if(person!=null){
log.info("命中缓存，结果为：{}" ,person.toString());
}else{
//模拟数据库查询
person = new Person();
person.setId(id);
person.setName("laowan");
person.setAge(25);
if(person!=null){
log.info("未命中缓存，从数据库查询结果为：{}",person.toString());
cacheService.setCache(key,person);
}
}
return person;
}
/**
* 通过传递回调函数，减少重复的查询缓存——》判空——》然后查询数据库——》判空——》更新缓存 编码操作
* @param id
* @return
*/
@Override
public Person getPersonWithCallBack(Integer id){
String key = person_cache_key + id;
Person person = cacheService.getCache(key, Person.class, new CacheCallBack<Person, String>() {
@Override
public Person execute(String input) {
//模拟数据库查询
Person personDB = new Person();
personDB.setId(id);
personDB.setName("laowan");
personDB.setAge(25);
return personDB;
}
});
return person;
}
单元测试：
@SpringBootTest
@Slf4j
class RedisApplicationTests {
@Autowired
PersonService personService;
@Test
void getTest() {
Person person = personService.get(102);
log.info("查询结果为：" + person.toString());
}
@Test
void getPersonTest() {
Person person = personService.getPerson(102);
log.info("查询结果为：" + person.toString());
}
@Test
void getPersonWithClosureTest() {
Person person = personService.getPersonWithCallBack(104);
log.info("查询结果为：" + person.toString());
}
}
总结
1、操作redis缓存的常见2种方式:Spring Cache注解方式和redisTemplate编码方式。
2、两种缓存操作方式的异常处理，实现业务操作和缓存解耦：缓存查询失败，会继续查询数据库执行业务。
3、redis缓存的序列化控制：默认使用java自带的序列化机制，存储的对象需要实现Serializable接口；这里我们配置的是采用Jackson序列化，所以不需要实现Serializable接口。
4、通过封装回调方法CacheCallBack，减少了重复的“查询缓存——》判空——》查询数据库——》判空——》更新缓存 ”的硬编码操作
实战代码Git地址：https://github.com/StarlightWANLI/redis.git
更多精彩，关注我吧。
