SpringBoot redis分布式缓存实现过程解析

2023-08-10 02:33:03 315

前言

应用系统需要通过Cache来缓存不经常改变得数据来提高系统性能和增加系统吞吐量，避免直接访问数据库等低速存储系统。缓存的数据通常存放在访问速度更快的内存里或者是低延迟存取的存储器，服务器上。应用系统缓存，通常有如下作用：缓存web系统的输出，如伪静态页面。缓存系统的不经常改变的业务数据，如用户权限，字典数据.配置信息等

大家都知道springBoot项目都是微服务部署，A服务和B服务分开部署，那么它们如何更新或者获取共有模块的缓存数据，或者给A服务做分布式集群负载，如何确保A服务的所有集群都能同步公共模块的缓存数据，这些都涉及到分布式系统缓存的实现。（ehcache可以通过Terracotta组件一个缓存集群，这个暂时不讲）

但是ehcache的设计并不适合做分布式缓存，所以今天用redis来实现分布式缓存。

架构图：

一二级缓存服务器

使用Redis缓存，通过网络访问还是不如从内存中获取性能好，所以通常称之为二级缓存，从内存中取得的缓存数据称之为一级缓存。当应用系统需要查询缓存的时候，先从一级缓存里查找，如果有，则返回，如果没有查找到，则再查询二级缓存，架构图如下

SpringBoot2自带了前面俩种缓存的实现方式，本文将简单实现第三种，高速一二级缓存实现

Redis分布式缓存

引入redis的starter

配置Redis

在application.yml中配置redis信息

spring:
redis:
database:0
host:192.168.0.146
port:6379
timeout:5000

其他相关配置

#Redis数据库索引（默认为0）
spring.redis.database=0
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=0

配置Redis缓存序列化机制

有的时候需要将对象存进redis（例如一个JavaBean对象），但是如果对象不是可Serializable的，因此需要让JavaBean对象实现Serializable接口

publicclassUserPOimplementsSerializable{

如果只是让JavaBean实现Serializable接口也是可以存储的，但是并不好看，那么能不能将JavaBean弄成Json的样式放进redis呢。直接的方式就是自己转换，但是未免有点麻烦，那就只能修改RedisTemplate的序列化机制了，在配置类中配置上序列化的方法即可

@Bean
publicRedisTemplateredisTemplate(RedisConnectionFactoryfactory){

RedisTemplatetemplate=newRedisTemplate();
template.setConnectionFactory(factory);

Jackson2JsonRedisSerializerjacksonSeial=newJackson2JsonRedisSerializer(Object.class);
ObjectMapperom=newObjectMapper();
om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);

//值采用json序列化
template.setValueSerializer(jacksonSeial);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(newStringRedisSerializer());
template.setHashKeySerializer(newStringRedisSerializer());
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();

returntemplate;
}

自定义CacheManager

/**
*选择Redis作为默认缓存工具
*@paramredisTemplate
*@return
*/
@Bean
publicCacheManagercacheManager(RedisConnectionFactoryredisConnectionFactory){

RedisCacheConfigurationredisCacheConfiguration=RedisCacheConfiguration.defaultCacheConfig();
returnRedisCacheManager
.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
.cacheDefaults(redisCacheConfiguration).build();

}

RedisConfig完整代码

importcom.fasterxml.jackson.annotation.JsonAutoDetect;
importcom.fasterxml.jackson.annotation.PropertyAccessor;
importcom.fasterxml.jackson.databind.ObjectMapper;
importorg.springframework.cache.CacheManager;
importorg.springframework.cache.annotation.CachingConfigurerSupport;
importorg.springframework.cache.interceptor.KeyGenerator;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.data.redis.cache.RedisCacheConfiguration;
importorg.springframework.data.redis.cache.RedisCacheManager;
importorg.springframework.data.redis.cache.RedisCacheWriter;
importorg.springframework.data.redis.connection.RedisConnectionFactory;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
importorg.springframework.data.redis.serializer.StringRedisSerializer;

importjava.lang.reflect.Method;
importjava.net.UnknownHostException;



@Configuration
publicclassRedisConfigextendsCachingConfigurerSupport{

/**
*选择Redis作为默认缓存工具
*@paramredisTemplate
*@return
*/
@Bean
publicCacheManagercacheManager(RedisConnectionFactoryredisConnectionFactory){

RedisCacheConfigurationredisCacheConfiguration=RedisCacheConfiguration.defaultCacheConfig();
returnRedisCacheManager
.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
.cacheDefaults(redisCacheConfiguration).build();

}


/**
*retemplate相关配置(序列化机制对象)
*@paramfactory
*@return
*/
@Bean
publicRedisTemplateredisTemplate(RedisConnectionFactoryfactory){

RedisTemplatetemplate=newRedisTemplate();
//配置连接工厂
template.setConnectionFactory(factory);

//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializerjacksonSeial=newJackson2JsonRedisSerializer(Object.class);

ObjectMapperom=newObjectMapper();
//指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
//指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);

//值采用json序列化
template.setValueSerializer(jacksonSeial);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(newStringRedisSerializer());

//设置hashkey和value序列化模式
template.setHashKeySerializer(newStringRedisSerializer());
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();

returntemplate;
}


/**
*自定义key的生成策略
*@return
*/
@Bean
publicKeyGeneratormyKeyGenerator(){
returnnewKeyGenerator(){
@Override
publicObjectgenerate(Objecttarget,Methodmethod,Object...params){
StringBuildersb=newStringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for(Objectobj:params){
sb.append(obj.toString());
}
returnsb.toString();
}
};
}
}

使用Redi缓存注解

service：

@CachePut(value="user",key="'user_'+#result.id")
publicUserPOsave(UserPOpo){
userJpaMapper.save(po);
returnpo;
}

@CachePut(value="user",key="'user_'+#result.id")
publicUserPOupdate(UserPOpo){
System.out.println("数据库更新");
userMapper.update(po);
returnpo;
}

@Cacheable(value="user",key="'user_'+#id")
publicUserPOgetUser(Integerid){
System.out.println("访问数据库："+id);
returnuserJpaMapper.getOne(id);
}

@CacheEvict(value="user",key="'user_'+#id")
publicvoiddelete(Integerid){
userJpaMapper.deleteById(id);
}

测试类：

@Test
voidcontextLoads(){
Integerid=2;
UserPOuser1=userService.getUser(id);
System.out.println("第一次查询："+user1.getUserName());

UserPOuser2=userService.getUser(id);
System.out.println("第二次查询："+user2.getUserName());
}

测试结果：第一次查询的时候访问了数据库，第二次查询的时候并没有访问数据库

通过redis-cli可以查看到数据已经保存到了redis上面

测试类：

@Test
voidupdataUser(){
Integerid=4;
UserPOuser1=userService.getUser(id);
System.out.println("第一次查询："+user1.getUserName()+",年龄："+user1.getAge());

user1.setAge(60);
userService.update(user1);

UserPOuser2=userService.getUser(id);
System.out.println("第二次查询："+user2.getUserName()+",年龄："+user2.getAge());
}

测试结果：

Redis工具类（redisUtil.java）

1.在RedisConfig中定义redisTemplate操作对象

/**
*对hash类型的数据操作
*@paramredisTemplate
*@return
*/
@Bean
publicHashOperationshashOperations(RedisTemplateredisTemplate){
returnredisTemplate.opsForHash();
}

/**
*对redis字符串类型数据操作
*@paramredisTemplate
*@return
*/
@Bean
publicValueOperationsvalueOperations(RedisTemplateredisTemplate){
returnredisTemplate.opsForValue();
}

/**
*对链表类型的数据操作
*@paramredisTemplate
*@return
*/
@Bean
publicListOperationslistOperations(RedisTemplateredisTemplate){
returnredisTemplate.opsForList();
}

/**
*对无序集合类型的数据操作
*@paramredisTemplate
*@return
*/
@Bean
publicSetOperationssetOperations(RedisTemplateredisTemplate){
returnredisTemplate.opsForSet();
}

/**
*对有序集合类型的数据操作
*@paramredisTemplate
*@return
*/
@Bean
publicZSetOperationszSetOperations(RedisTemplateredisTemplate){
returnredisTemplate.opsForZSet();
}

2.在redisUtil工具类中使用这些对象，并构建其操作方法

packagecom.meng.demo.utils;

importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.data.redis.core.*;
importorg.springframework.stereotype.Component;
importorg.springframework.util.CollectionUtils;

importjava.util.List;
importjava.util.Map;
importjava.util.Set;
importjava.util.concurrent.TimeUnit;


/**
*redis工具类
*/
@Component
publicclassRedisUtil{
@Autowired
privateRedisTemplateredisTemplate;
@Autowired
privateValueOperationsvalueOperations;
@Autowired
privateHashOperationshashOperations;
@Autowired
privateListOperationslistOperations;
@Autowired
privateSetOperationssetOperations;
@Autowired
privateZSetOperationszSetOperations;


/**=============================共同操作============================*/
/**
*指定缓存失效时间
*@paramkey键
*@paramtime时间(秒)
*@return
*/
publicbooleanexpire(Stringkey,longtime){
try{
if(time>0){
redisTemplate.expire(key,time,TimeUnit.SECONDS);
}
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

/**
*根据key获取过期时间
*@paramkey键不能为null
*@return时间(秒)返回0代表为永久有效
*/
publiclonggetExpire(Stringkey){
returnredisTemplate.getExpire(key,TimeUnit.SECONDS);
}
/**
*判断key是否存在
*@paramkey键
*@returntrue-存在、false-不存在
*/
publicbooleanhasKey(Stringkey){
try{
returnredisTemplate.hasKey(key);
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}
/**
*删除缓存
*@paramkey可以传一个值或多个
*/
publicvoiddel(String...key){
if(key!=null&&key.length>0){
if(key.length==1){
redisTemplate.delete(key[0]);
}else{
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
/**============================ValueOperations操作=============================*/
/**
*普通缓存放入
*@paramkey键
*@paramvalue值
*@returntrue-成功、false-失败
*/
publicbooleanset(Stringkey,Objectvalue){
try{
valueOperations.set(key,value);
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}
/**
*普通缓存放入并设置时间
*@paramkey键
*@paramvalue值
*@paramexpireTime时间(秒)expireTime要大于0如果expireTime小于等于0将设置无限期
*@returntrue成功false失败
*/
publicbooleanset(Stringkey,Objectvalue,longexpireTime){
try{
if(expireTime>0){
valueOperations.set(key,value,expireTime,TimeUnit.SECONDS);
}else{
set(key,value);
}
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}
/**
*普通缓存获取
*@paramkey键
*@return值
*/
publicObjectget(Stringkey){
returnkey==null?null:valueOperations.get(key);
}
/**
*递增
*@paramkey键
*@return
*/
publiclongincr(Stringkey,longdelta){
if(delta<0){
thrownewRuntimeException("递增因子必须大于0");
}
returnvalueOperations.increment(key,delta);
}
/**
*递减
*@paramkey
*@paramdelta要减少几(小于0)
*@return
*/
publiclongdecr(Stringkey,longdelta){
if(delta<0){
thrownewRuntimeException("递减因子必须大于0");
}
returnvalueOperations.increment(key,-delta);
}

/**================================HashOperations操作=================================*/
/**
*HashGet
*@paramkey键不能为null
*@paramitem项不能为null
*@return值
*/
publicObjecthget(Stringkey,Stringitem){
returnhashOperations.get(key,item);
}

/**
*获取hashKey对应的所有键值
*@paramkey键
*@return对应的多个键值
*/
publicMaphmget(Stringkey){
returnhashOperations.entries(key);
}

/**
*HashSet
*@paramkey键
*@parammap对应多个键值
*@returntrue成功false失败
*/
publicbooleanhmset(Stringkey,Mapmap){
try{
hashOperations.putAll(key,map);
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

/**
*HashSet并设置时间
*@paramkey键
*@parammap对应多个键值
*@paramtime时间(秒)
*@returntrue成功false失败
*/
publicbooleanhmset(Stringkey,Mapmap,longtime){
try{
hashOperations.putAll(key,map);
if(time>0){
expire(key,time);
}
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

/**
*向一张hash表中放入数据,如果不存在将创建
*@paramkey键
*@paramitem项
*@paramvalue值
*@returntrue成功false失败
*/
publicbooleanhset(Stringkey,Stringitem,Objectvalue){
try{
hashOperations.put(key,item,value);
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

/**
*向一张hash表中放入数据,如果不存在将创建
*@paramkey键
*@paramitem项
*@paramvalue值
*@paramtime时间(秒)注意:如果已存在的hash表有时间,这里将会替换原有的时间
*@returntrue成功false失败
*/
publicbooleanhset(Stringkey,Stringitem,Objectvalue,longtime){
try{
hashOperations.put(key,item,value);
if(time>0){
expire(key,time);
}
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

/**
*删除hash表中的值
*@paramkey键不能为null
*@paramitem项可以使多个不能为null
*/
publicvoidhdel(Stringkey,Object...item){
hashOperations.delete(key,item);
}

/**
*判断hash表中是否有该项的值
*@paramkey键不能为null
*@paramitem项不能为null
*@returntrue存在false不存在
*/
publicbooleanhHasKey(Stringkey,Stringitem){
returnhashOperations.hasKey(key,item);
}

/**
*hash递增如果不存在,就会创建一个并把新增后的值返回
*@paramkey键
*@paramitem项
*@paramby要增加几(大于0)
*@return
*/
publicdoublehincr(Stringkey,Stringitem,doubleby){
returnhashOperations.increment(key,item,by);
}

/**
*hash递减
*@paramkey键
*@paramitem项
*@paramby要减少记(小于0)
*@return
*/
publicdoublehdecr(Stringkey,Stringitem,doubleby){
returnhashOperations.increment(key,item,-by);
}

/**============================set=============================
/**
*根据key获取Set中的所有值
*@paramkey键
*@return
*/
publicSet

SpringBoot redis分布式缓存实现过程解析

热门推荐

随机推荐