springboot cache redis优雅实现缓存

导读

你还在代码里面写查询数据，然后写入缓存代码吗？没错，你曾经应该都是这么做，做得很累，代码很臃肿，那么从本文开始，可以抛掉了，让我们缓存代码更加优雅起来，更加简单起来。

Spring Cache前身

Spring cache是使用org.springframework.cache.Cache和org.springframework.cache.CacheManager来管理接口，其中CacheManager是Spring提供的各种缓存技术的抽象接口。而Cache接口包含缓存的各种操作。

Cache接口是缓存组件规范，操作各种缓存数据，提供支持各种缓存框架实现，如：RedisCache，ConcurrentMapCache，EhcacheCache等，RedisCache是我们最常用的。

Spring cache 使用注解来简化实现缓存开发，是基于AOP技术实现。

Spring CacheManger相关技术说明

SimpleCacheManager	                使用简单的来存储缓存,单一存储,很少用
ConcurrentMapCacheManager	  使用ConcurrentMap作为缓存技术（默认），需要显式的删除缓存，无过期机制
NoOpCacheManager	                 不用存储缓存
EhCacheCacheManager	              使用EhCache作为缓存技术，以前在很老系统可能用到
GuavaCacheManager	                  使用google guava cache作为缓存技术
CaffeineCacheManager	              是使用Java8对Guava缓存的重写，spring5（springboot2）开始用Caffeine取代guava
HazelcastCacheManager	             使用Hazelcast作为缓存技术
JCacheCacheManager	                使用JCache标准的实现作为缓存技术，如Apache Commons JCS
RedisCacheManager	                    使用Redis作为缓存技术

最常用：RedisCacheManager，系统默认使用ConcurrentMapCacheManager是单机JVM内存，不适合分布式多台服务

缓存概念以及注解说明

Cache	                  缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等
CacheManager	   缓存管理器，管理各种缓存组件,如上说明

@Cacheable	        主要针对方法配置，能够根据方法的请求参数对其进行缓存(必用)
@CacheEvict	        清空缓存(必用)
@CachePut	          保证方法被调用，更新结果被缓存。常用于更新后操作(可用)

@EnableCaching	 开启基于注解的缓存(必须)

@CacheConfig	    统一配置本类的缓存注解的属性(可用)

keyGenerator	      缓存数据时key生成策略
serialize	                缓存数据时value序列化策略

@Cacheable/@CachePut/@CacheEvict 重要参数说明

参数：value         缓存名称，必填，如：@Cacheable(value = "user")
参数：key            缓存key，非必填，使用SpEL表达式，一般用在参数中，如：@Cacheable(value = "user",key = "#userId")
参数：condition  表达式条件满足缓存，非必填，使用SpEL表达式，满足条件true缓存，false不缓存，如：@Cacheable(value = "user:condition",condition="#userPO.userName.length()>2")
参数：unless       表达式条件满足不缓存，非必填，使用SpEL表达式，跟condition参数反向，如：@Cacheable(value = "user:unless",unless ="#userPO.id>3")
参数：sync           @Cacheable特有，多线程情况下可能出现重复载入缓存情况，设置为true可解决，默认是false
参数：allEntries   @CacheEvict特有，清除下面value下面所有的::缓存数据，设置不设置key参数都不影响删除结果，如：@CacheEvict(value = "user",key = "#userPO.id",allEntries = true)
参数：beforeInvocation 
                           @CacheEvict特有，是否执行方法前就清除了数据，默认是false执行方法后再清除缓存，设置true执行方法前就清除了数据。
                            如：@CacheEvict(value = "user",key = "#userPO.id",allEntries = true,beforeInvocation = true)

注解：@CachePut     更新缓存后，又重新把数据放入缓存，如：@CachePut(value = "user",key = "#userPO.id")

SpEL表达式说明

名称	                         位置	                    描述	                                                                          示例
methodName	         root对象	             当前被调用的方法名	                                                  #root.methodname
method	                   root对象	            当前被调用的方法	                                                      #root.method.name
target	                      root对象	           当前被调用的目标对象实例                          	               #root.target
targetClass	               root对象	            当前被调用的目标对象的类	                                        #root.targetClass
args	                         root对象	            当前被调用的方法的参数列表	                                      #root.args[0]
caches	                     root对象	            当前方法调用使用的缓存列表	                                      #root.caches[0].name
Argument  Name	    执行上下文	        当前被调用的方法的参数
                                                            如：getUser(User user),可以通过#user.id获得参数	     #user.id
result	                       执行上下文	       方法执行后的返回值（仅当方法执行后的判断有效）      #result

SpEL运算符

类型	               运算符
关系	               <，>，<=，>=，==，!=，lt，gt，le，ge，eq，ne
算术	               +，- ，* ，/，%，^
逻辑	               &&，||，!，and，or，not，between，instanceof
条件	               ?: (ternary)，?: (elvis)
正则表达式	      matches
其他类型	        ?.，?[…]，![…]，^[…]，$[…]

开始项目

新建一个springboot项目，导入springboot依赖包版本，同时项目新增改查依赖mybatis-plus具体整合，日志用lombok，不懂整合这两个技术的可以咨询我

 <!-- 引入springboot版本依赖包 -->
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/>
   </parent>
 <!-- 引入springboot-web版本依赖包 -->
  <dependencies>
    
  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

引入SpringBoot Cache依赖包

<!-- springboot cache 依赖 -->
<dependency>
		    <groupId>org.springframework.boot</groupId>
		    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

整合Redis依赖包

<!-- 整合 Redis -->
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置application.properties

server.port=8010
server.servlet.context-path=/

################ Redis 基础配置 ##############
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 链接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000

编写SpringBoot启动类

@SpringBootApplication
public class UserProvideApp 
{
    public static void main( String[] args )
    {
        SpringApplication.run(UserProvideApp.class, args);
    }
}

编写开启@EnableCaching注解类

创建SpringCacheConfig类，在该类上新增@EnableCaching注解,该注解是必须要配置的，也可以直接配置在启动类UserProvideApp上

/**
 * 开启 @EnableCaching 注解，必须要开启才能用到缓存注解类<br>
 * 这个注解可以配置在启动类上
 */
@Configuration
@EnableCaching
public class SpringCacheConfig {

}

新建UserPO

@Data
@EqualsAndHashCode(callSuper = false)
@TableName("user")
public class UserPO implements Serializable {

    private static final long serialVersionUID=1L;

    /**
     * 用户ID
     */
    private Long id;

    /**
     * 用户名
     */
    private String userName;
    
    /**
     * 密码
     */
    private String pwd;
    
    /**
     * 回答总数
     */
    private Integer qaReplyCount;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

新建UserCacheService缓存类

UserCacheServiceImpl实现类如下，UserCacheService自行实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hsb.user.po.UserPO;
import com.hsb.user.provide.dao.UserDAO;

import lombok.extern.slf4j.Slf4j;

/**
 * 用户缓存,业务接口
 */
@Service
@Slf4j
public class UserCacheServiceImpl implements UserCacheService{
	
	@Autowired
	UserDAO userDAO;
	
    /**
     * 参数缓存<br>
     * value 参数必填，缓存名称<br>
     * key   缓存key，参数表达式要和参数名称一样<br>
     * 最终缓存key user:(userId)组合,如：user::2<br>
     */
	@Cacheable(value = "user",key = "#userId")//user:1
	public UserPO getByUserId(Long userId) {
		log.info("查询用户ID={}",userId);
		return userDAO.selectById(userId);
	}
	
	/**
	 * 对象参数缓存<br>
     * value 参数必填，缓存名称<br>
     * key   缓存key，参数表达式要和对象参数名称一样<br>
     * 最终缓存key user:po:(userId)组合<br>
     */
	@Cacheable(value = "user:po",key = "#userPO.id")//user:1
	public UserPO getByUser(UserPO userPO) {
		log.info("查询用户userPO={}",userPO);
		QueryWrapper<UserPO> queryWrapper=new QueryWrapper<UserPO>(userPO);
		return userDAO.selectOne(queryWrapper);
	}

	/**
	 * 表达式缓存,满足条件缓存<br>
     * value 参数必填，缓存名称<br>
     * condition   表达式，满是缓存<br>
     * 最终缓存key user:condition:(userName)组合<br>
     */
	@Cacheable(value = "user:condition",key = "#userPO.userName",condition="#userPO.userName.length()>2")
	public UserPO getByUserCondition(UserPO userPO) {
		log.info("查询用户UserCondition={}",userPO);
		QueryWrapper<UserPO> queryWrapper=new QueryWrapper<UserPO>(userPO);
		return userDAO.selectOne(queryWrapper);
	}

	/**
	 * 表达式缓存,满足条件不缓存，反之缓存，跟condition参数刚刚相反<br>
	 * 
     * value 参数必填，缓存名称<br>
     * unless   表达式，满足不缓存<br>
     * 最终缓存key user:cunless:组合<br>
     */
	@Cacheable(value = "user:unless",unless ="#userPO.id>3")
	public UserPO getByUserUnless(UserPO userPO) {
		log.info("查询用户UserUnless={}",userPO);
		QueryWrapper<UserPO> queryWrapper=new QueryWrapper<UserPO>(userPO);
		return userDAO.selectOne(queryWrapper);
	}
	
	/**
	 * 1、删除数据<br>
	 * 
	 * 2、清除缓存<br>
	 * 
	 * 3、参数：allEntries 清除下面value下面所有的::缓存数据，设置不设置key参数不影响删除结果<br>
	 * 如：清除：user::xx 所有数据<br>
	 * 4、如果想删除指定value+key,去掉allEntries参数即可<br>
	 * 
	 * @param userPO
	 * @return
	 */
	@CacheEvict(value = "user",key = "#userPO.id",allEntries = true)
	public int delUserPo(UserPO userPO) {
		log.info("删除用户userPO={}",userPO);
		QueryWrapper<UserPO> queryWrapper=new QueryWrapper<UserPO>(userPO);
		return userDAO.delete(queryWrapper);
	}
	
	/**
	 * 1、删除数据<br>
	 * 2、清除指定key缓存,不是删除value下面所有所有<br>
	 * 3、beforeInvocation 是否执行方法前就清除了数据，默认是false执行方法后再清除缓存，设置true执行方法前就清除了数据<br>
	 * 4、异常测试，指定方法前指定了删除操作<br>
	 * 
	 * @param userPO
	 * @return
	 */
	@CacheEvict(value = "user",key = "#userPO.id",beforeInvocation = true)
	public int delUserPoBybeforeInvocation(UserPO userPO) {
		log.info("删除用户beforeInvocation-userPO={}",userPO);
		int i=1/0;//异常测试,指定方法前指定了删除操作
		QueryWrapper<UserPO> queryWrapper=new QueryWrapper<UserPO>(userPO);
		return userDAO.delete(queryWrapper);
	}
	
	/**
	 * @CachePut 注解使用<br>
	 * 
	 * 更新用户后，从新把更新信息放入缓存<br>
	 * 
	 * @param userPO
	 * @return
	 */
	@CachePut(value = "user",key = "#userPO.id")
	public UserPO updateUser(UserPO userPO) {
		log.info("更新用户userPO={}",userPO);
		int rt=userDAO.updateById(userPO);
		if(rt<=0) {
			throw new RuntimeException("更新用户失败userPo="+userPO);
		}
		return getByUser(userPO);
	}
}

编写UserCacheController

/**
 * 用户缓存测试
 */
@RestController
@RequestMapping("/user/cache")
public class UserCacheController {
	
	@Autowired
	UserCacheService userCacheService;
	
	@GetMapping("/getByUserId")
	public UserPO getByUserId(Long userId) {
		return userCacheService.getByUserId(userId);
	}
	
	/**
	 * 对象参数缓存
     * value 参数必填，缓存名称
     * key   缓存key，参数表达式要和对象参数名称一样
     * 最终缓存key user:po:(userId)组合
     */
	@GetMapping("/getByUser")
	public UserPO getByUser(UserPO userPO) {
		return userCacheService.getByUser(userPO);
	}

	/**
	 * 表达式缓存,满足条件缓存
     * value 参数必填，缓存名称
     * condition   表达式，满是缓存
     * 最终缓存key user:condition:(userName)组合
     */
	@GetMapping("/getByUserCondition")
	public UserPO getByUserCondition(UserPO userPO){
		return userCacheService.getByUserCondition(userPO);
	}

	/**
	 * 表达式缓存,满足条件不缓存，跟condition参数刚刚相反
	 * 
     * value 参数必填，缓存名称
     * unless   表达式，满足不缓存
     * 最终缓存key user:cunless:组合
     */
	@GetMapping("/getByUserUnless")
	public UserPO getByUserUnless(UserPO userPO) {
		return userCacheService.getByUserUnless(userPO);
	}
	
	/**
	 * 删除数据
	 * 
	 * 清除缓存
	 * 
	 * 参数：allEntries 清除下面所有的缓存数据
	 * 
	 * @param userPO
	 * @return
	 */
	@GetMapping("/delUserPo")
	public int delUserPo(UserPO userPO){
		return userCacheService.delUserPo(userPO);
	}
	
	/**
	 * 删除数据
	 * 
	 * beforeInvocation 是否执行方法前就清除了数据，默认是false执行方法后再清除缓存，设置true执行方法前就清除了数据
	 * 
	 * @param userPO
	 * @return
	 */
	@GetMapping("/delUserPoBybeforeInvocation")
	public int delUserPoBybeforeInvocation(UserPO userPO){
		return userCacheService.delUserPoBybeforeInvocation(userPO);
	}
	
	/**
	 * @CachePut 注解使用
	 * 
	 * 更新用户后，从新把更新信息放入缓存
	 * 
	 * @param userPO
	 * @return
	 */
	@GetMapping("/updateUser")
	public UserPO updateUser(UserPO userPO){
		return userCacheService.updateUser(userPO);
	}
}

启动服务

启动服务，就可以通过浏览器访问测试每个使用的效果了。

测试地址    如：http://127.0.0.1:8010/user/cache/getByUserId?userId=8

看到缓存结果

其他测试接口，如有不懂的，可以关注我，跟我私聊。

从上面可以看到缓存结果是一推密密麻麻的乱码，看不懂，这是因为默认采用的是JdkSerializationRedisSerializer序列化，如果你想把这个结果看得懂，如结果使用json格式，那么也是转换成指定的序列即。

引入Fastjson依赖

 <!--alibaba fastjson -->
         <dependency>
		  	<groupId>com.alibaba</groupId>
		  	<artifactId>fastjson</artifactId>
		  	<version>1.2.73</version>
		  </dependency>

新增序列化Bean

在SpringCacheConfig类上，编写配置Fastjson序列化对象，如下

/**
	  * 配置Fastjson序列化对象种作为缓存结果
	  * @return
	  */
	 @Bean  
	 public RedisCacheConfiguration redisCacheConfiguration() {
	    //使用fastjson序列化对象
		RedisSerializer<?> valSeri=new GenericFastJsonRedisSerializer();
	    return RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valSeri));
	 }

重启服务

重新访问测试上面路径，就可以看到缓存结果是json格式了，如下图所示：

缓存过期时间

经过以上发现，没有哪个参数可以设置一下过期时间，现在需求就是设置一下缓存过期时间，那么如何做呢？我们需要重新编辑SpringCacheConfig类上面序列化Bean代码，如下重写代码

/**
	  * 配置Fastjson序列化对象种作为缓存结果
	  * @return
	  */
	 @Bean  
	 public RedisCacheConfiguration redisCacheConfiguration() {
	    //使用fastjson序列化对象
		RedisSerializer<?> valSeri=new GenericFastJsonRedisSerializer();
		
		RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
			.serializeValuesWith(
	            RedisSerializationContext
	                .SerializationPair
	                .fromSerializer(valSeri)
	        ).entryTtl(Duration.ofSeconds(30));//所有的缓存都是默认30秒后过期

	    return redisCacheConfiguration;
	 }

这样就可以设置所有缓存key都是30秒以上都过期了，很简单吧。

现在问题又来了，如果需要对特定的缓存名称，设置不同时间呢？那又如何处理？我们得继续改进配置SpringCacheConfig缓存序列相关配置对象，代码如下

   //================配置特定key缓存过期时间================
	 /**
	  * 新增配置缓存管理Bean
	  * @param redisConnectionFactory
	  * @return
	  */
	 @Bean
	 public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
		 CacheManager cacheManager=new RedisCacheManager(
				  RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)
				 , defaulRedisCacheConfiguration() //默认缓存配置30秒过期
				 , redisCacheConfigurationMap());//指定缓存key过期
		 return cacheManager;
	 }
	 
	 /**
	  * 配置过期时间
	  * @param seconds
	  * @return
	  */
	 private RedisCacheConfiguration redisCacheConfiguration(Long seconds) {
		    //使用fastjson序列化对象
			RedisSerializer<?> valSeri=new GenericFastJsonRedisSerializer();
			
			RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
				.serializeValuesWith(
		            RedisSerializationContext
		                .SerializationPair
		                .fromSerializer(valSeri)
		        ).entryTtl(Duration.ofSeconds(seconds));//所有的缓存都是默认30秒后过期

		    return redisCacheConfiguration;
		 }
	 
	 /**
	  * 配置多个value配置使用不同配置
	  * @return
	  */
	 private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap(){
		 Map<String, RedisCacheConfiguration> map=new HashMap<String, RedisCacheConfiguration>();
		 map.put("user", redisCacheConfiguration(20l));//指定value=user 缓存过期为20秒
		 map.put("user:po", redisCacheConfiguration(15l));//指定value=user:po 缓存过期为15秒
		 return map;
	 }

代码里面就指定了特定value缓存名称对应的过期时间，如果有新的需要单独处理，新增代码Map对象即可，重启服务，测试通过

总结

利用springboot整合spring cache，redis，fastjson优雅实现了缓存存在，大大地提高开发效率，满足了部分缓存业务实现功能，唯一不足地方就是该框架缓存过期时间设计的不是非常灵活，有点繁琐，但是整体还是不错的，如大家使用或者觉得不理解的地方，欢迎大家讨论。