注解方式使用redis--Spring Cache

冷不防 2024-04-18 13:04 33阅读 0赞

### 文章目录 ###

*   *  几个重要概念&缓存注解
     *  配置@CacheConfig
     *  缓存@Cacheable
     *  更新@CachePut
     *  组合@Caching

注解方式使用redis:

问题:
    			我们在使用原生的RedisTemplate在Spring中完成对redis的
    			操作时，发现，redis缓存的校验和缓存同步的代码需要我们在
    			业务层方法中自己实现。
    			如果业务层方法过多，需要频繁的声明
    			redis的操作代码。如果原来项目中没有使用redis，现在要使用
    			redis，则需要修改业务层的代码。
    	方案：
    			其实说白了，我们对项目增加redis的操作，本质上
    			是在保留原有业务层操作的基础上增加redis的操作，完全符合AOP
    			机制，使用AOP对业务层方法进行扩展。
    		查询：
    				前置通知:校验redis缓存，如果有则直接返回，没有则
    					  继续调用业务层切点方法	、
    				切点：正常书写原有业务逻辑
    				后置通知:将切点的返回值缓存到redis库中
    		删除:
    				前置通知:删除redis缓存数据
    				切点：正常删除数据库中的数据
    		增加:
    				前置通知:删除redis缓存数据
    				切点：正常增加数据库中的数据
    				后置通知：将增加的数据缓存起来
    		修改:
    				前置通知:删除redis缓存数据
    				切点：正常增加数据库中的数据
    				后置通知：将增加的数据缓存起来
    	实现：
    			Spring中已经把AOP相关通知类已经声明好了，我们
    			只需要将通知添加给业务层方法即可--->Spring Cache
    	特点：
    			支持使用注解的方式在业务层上直接声明通知操作。
    	实现:
    			参照源码

从3.1开始，Spring引入了对Cache的支持  
  定义了`org.springframework.cache.Cache和org.springframework.cache.CacheManager`接口来统一不同的缓存技术  
  其使用方法和原理都类似于Spring对事务管理的支持。  
  Spring Cache是作用在方法上的，其核心思想是这样的：  
    当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的参数来调用该方法时将不再执行该方法，而是 直接从缓存中获取结果进行返回。  
  所以在使用Spring Cache的时候我们要保证我们缓存的方法对于相同的方法参数要有相同的返回结果。

*  Cache接口为缓存的组件规范定义，包含缓存的各种操作集合
 *  Cache接口下Spring提供了各种xxxCache的实现；如`RedisCache，EhCacheCache ,ConcurrentMapCache`等
 *  每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取

**使用Spring Cache需要我们做的事：**  
     1.声明某些方法使用缓存  
     2. 配置Spring对Cache的支持  
     3.从缓存中读取之前缓存存储的数据

**基于注解的支持**  
    Spring为我们提供了几个注解来支持Spring Cache。  
    其核心主要是`@Cacheable和@CacheEvict`。  
    使用@Cacheable标记的方法在执行后Spring Cache将缓存其返回结果，而使用@CacheEvict标记的方法会在方法执行前或者执行后移除Spring Cache中的某些元素。  
    下面我们将来详细介绍一下Spring基于注解对Cache的支持所提供的几个注解。

## 几个重要概念&缓存注解 ##

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Cacheable</td> 
   <td>主要针对方法配置，能够根据方法的请求参数对其进行缓存</td> 
  </tr> 
  <tr> 
   <td>@CacheEvict</td> 
   <td>清空缓存数据</td> 
  </tr> 
  <tr> 
   <td>@CachePut</td> 
   <td>保证方法被调用，又希望结果被缓存。与@Cacheable区别在于是否每次都调用方法，常用于更新</td> 
  </tr> 
  <tr> 
   <td>@EnableCaching</td> 
   <td>开启基于注解的缓存</td> 
  </tr> 
  <tr> 
   <td>@CacheConfig</td> 
   <td>声明公共key,统一配置本类的缓存注解的属性</td> 
  </tr> 
  <tr> 
   <td>keyGenerator</td> 
   <td>缓存数据时key生成策略</td> 
  </tr> 
  <tr> 
   <td>Cache</td> 
   <td>缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等</td> 
  </tr> 
  <tr> 
   <td>CacheManager</td> 
   <td>缓存管理器，管理各种缓存（cache）组件</td> 
  </tr> 
  <tr> 
   <td>serialize</td> 
   <td>缓存数据时value序列化策略</td> 
  </tr> 
 </tbody> 
</table>

**@Cacheable/@CachePut/@CacheEvict 主要的参数**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>value</td> 
   <td>缓存的名称，在 spring 配置文件中定义，必须指定至少一个<br>例如：<br>@Cacheable(value=”mycache”) 或者<br>@Cacheable(value={”cache1”,”cache2”}</td> 
  </tr> 
  <tr> 
   <td>key</td> 
   <td>缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，<br>如果不指定，则缺省按照方法的所有参数进行组合<br>例如：<br>@Cacheable(value=”testcache”,key=”#id”)</td> 
  </tr> 
  <tr> 
   <td>condition</td> 
   <td>缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，<br>只有为 true 才进行缓存/清除缓存<br>例如：@Cacheable(value=”testcache”,condition=”#userName.length()&gt;2”)</td> 
  </tr> 
  <tr> 
   <td>unless</td> 
   <td>否定缓存。当条件结果为TRUE时，就不会缓存。<br>@Cacheable(value=”testcache”,unless=”#userName.length()&gt;2”)</td> 
  </tr> 
  <tr> 
   <td>allEntries<br>(@CacheEvict )</td> 
   <td>是否清空所有缓存内容，缺省为 false，如果指定为 true，<br>则方法调用后将立即清空所有缓存<br>例如：<br>@CachEvict(value=”testcache”,allEntries=true)</td> 
  </tr> 
  <tr> 
   <td>beforeInvocation<br>(@CacheEvict)</td> 
   <td>是否在方法执行前就清空，缺省为 false，如果指定为 true，<br>则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法<br>执行抛出异常，则不会清空缓存<br>例如：<br>@CachEvict(value=”testcache”，beforeInvocation=true)</td> 
  </tr> 
 </tbody> 
</table>

**SpringEL上下文数据，下表直接摘自Spring官方文档：**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>位置</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>methodName</td> 
   <td>root对象</td> 
   <td>当前被调用的方法名<br>使用当期方法的名字作为key</td> 
   <td>#root.methodname</td> 
  </tr> 
  <tr> 
   <td>method</td> 
   <td>root对象</td> 
   <td>当前被调用的方法<br>当前方法对象为key</td> 
   <td>#root.method.name</td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象实例<br>当前被调用的对象为key</td> 
   <td>#root.target</td> 
  </tr> 
  <tr> 
   <td>targetClass</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象的类</td> 
   <td>#root.targetClass</td> 
  </tr> 
  <tr> 
   <td>args</td> 
   <td>root对象</td> 
   <td>当前被调用的方法的参数列表</td> 
   <td>#root.args[0]</td> 
  </tr> 
  <tr> 
   <td>caches</td> 
   <td>root对象</td> 
   <td>当前方法调用使用的缓存列表<br>使用@CacheConfig注解中声明的值为key</td> 
   <td>#root.caches[0].name</td> 
  </tr> 
  <tr> 
   <td>Argument Name</td> 
   <td>执行上下文</td> 
   <td>当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数 <br>使用指定的形参的属性值为key</td> 
   <td>#artsian.id</td> 
  </tr> 
  <tr> 
   <td>result</td> 
   <td>执行上下文</td> 
   <td>方法执行后的返回值（仅当方法执行后的判断有效，如 unless cacheEvict的beforeInvocation=false）</td> 
   <td>#result</td> 
  </tr> 
 </tbody> 
</table>

**注意：**  
    **key不能重复**  
    一个key有可能是多个方法在调用

1.当我们要使用root对象的属性作为key时可以将“\#root”**省略**，因为Spring默认使用的就是root对象的属性。 如

@Cacheable(key = "targetClass + methodName +#p0")

2.使用方法参数时我们可以直接使用“\#参数名”或者“\#p参数index”。 如：

@Cacheable(value="users", key="#id")
    
    			@Cacheable(value="users", key="#p0")

**导入依赖**

<dependency>
      		<groupId>org.springframework.data</groupId>
      		<artifactId>spring-data-redis</artifactId>
      		<version>1.8.9.RELEASE</version>
      	</dependency>
      	
      	<dependency>
      		<groupId>redis.clients</groupId>
      		<artifactId>jedis</artifactId>
      		<version>2.9.0</version>
      	</dependency>
      	  
      	<dependency>
    		<groupId>com.fasterxml.jackson.core</groupId>
    		<artifactId>jackson-databind</artifactId>
    		<version>2.8.2</version>
    	</dependency>

**applicationContext.xml**  
  主要是配置RedisCacheManager和缓存注解解析器

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
    
    	
    	<context:component-scan base-package="com.i.service.impl"></context:component-scan>
    
    	
    	<bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
    		<constructor-arg name="redisOperations" ref="redisTemplate"></constructor-arg>
    	</bean>
    	
    	<cache:annotation-driven/>
    
    	
    	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    		
    		<property name="connectionFactory" ref="jedisConnectionFactory"></property>
    		
    		<property name="keySerializer" ref="key"></property>
    		<property name="valueSerializer" ref="value"></property>
    	</bean>
    	
    	
    	<bean id="key" class="org.springframework.data.redis.serializer.GenericToStringSerializer">
    		<constructor-arg name="type" value="java.lang.String"></constructor-arg>
    	</bean>
    	
    	<bean id="value" class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"></bean>
    
    	
    	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    		<property name="hostName" value="192.168.230.172"></property>
    		<property name="port" value="6379"></property>
    	</bean>
    </beans>

## 配置@CacheConfig ##

当我们需要缓存的地方越来越多，你可以使用`@CacheConfig(cacheNames = {"myCache"})`注解来统一指定`value`的值，这时可省略`value`，如果你在你的方法依旧写上了`value`，那么依然以方法的`value`值为准。

使用方法如下：

@CacheConfig(cacheNames = { "myCache"})
    	public class UserService{ 
    	    @Override
    	    @Cacheable(key = "query")//此处没写value
    	    public List<User> query(int num) { 
    	        return userMapper.query(num);
    	    }
    	}

**查看它的其它属性**

String keyGenerator() default "";  //key的生成器。key/keyGenerator二选一使用
    	
    	String cacheManager() default "";  //指定缓存管理器
    	
    	String cacheResolver() default ""; //或者指定获取解析器

## 缓存@Cacheable ##

`@Cacheable`注解会先查询是否已经有缓存，有会使用缓存，没有则会执行方法并缓存。  
    当标记在一个方法上时表示该方法是支持缓存的，当标记在一个类上时则表示该类所有的方法都是支持缓存的。

@Cacheable(value = "emp" ,key = "target")
        public List<User> queryAll(User uid) { 
            return usermapper.findAllByUid(uid);
        }

此处的`value`是必需的，它指定了你的缓存存放在哪块命名空间。

此处的key是使用的spEL表达式。这里有一个小坑，如果你把`methodName`换成`method`运行会报错，观察它们的返回类型，原因在于`methodName`是`String`而`methoh`是`Method`。

此处的User实体类一定要实现**序列化**`public class User implements Serializable`，否则会报`java.io.NotSerializableException`异常。

到这里，你已经可以运行程序检验缓存功能是否实现。

深入源码，查看它的其它属性

打开@Cacheable注解的源码，可以看到该注解提供的其他属性，如：

String[] cacheNames() default {}; //和value注解差不多，二选一
    	
    	String keyGenerator() default ""; //key的生成器。key/keyGenerator二选一使用
    	
    	String cacheManager() default ""; //指定缓存管理器
    	
    	String cacheResolver() default ""; //或者指定获取解析器
    	
    	String condition() default ""; //条件符合则缓存
    	
    	String unless() default ""; //条件符合则不缓存
    	
    	boolean sync() default false; //是否使用异步模式

6.清除@CacheEvict

`@CachEvict` 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空 。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>解释</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>allEntries</td> 
   <td>是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存</td> 
   <td>@CachEvict(value=”testcache”,allEntries=true)</td> 
  </tr> 
  <tr> 
   <td>beforeInvocation</td> 
   <td>是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存</td> 
   <td>@CachEvict(value=”testcache”，beforeInvocation=true)</td> 
  </tr> 
 </tbody> 
</table>

示例：

@Cacheable(value = "emp",key = "#p0.id")
        public User save(User job) { 
            usermapper.save(job);
            return job;
        }
    
        //清除一条缓存，key为要清空的数据
        @CacheEvict(value="emp",key="#id")
        public void delect(int id) { 
            usermapper.deleteAllById(id);
        }
    
        //方法调用后清空所有缓存
        @CacheEvict(value="accountCache",allEntries=true)
        public void delectAll() { 
            usermapper.deleteAll();
        }
    
        //方法调用前清空所有缓存
        @CacheEvict(value="accountCache",beforeInvocation=true)
        public void delectAll() { 
            usermapper.deleteAll();
        }

其他属性

String[] cacheNames() default {}; //与value二选一
    	
    	String keyGenerator() default "";  //key的生成器。key/keyGenerator二选一使用
    	
    	String cacheManager() default "";  //指定缓存管理器
    	
    	String cacheResolver() default ""; //或者指定获取解析器
    	
    	String condition() default ""; //条件符合则清空

## 更新@CachePut ##

`@CachePut`注解的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 `@Cacheable` 不同的是，它每次都会触发真实方法的调用 。简单来说就是用户更新缓存数据。  
  但需要注意的是该注解的`value` 和 `key` 必须与要更新的缓存相同，也就是与`@Cacheable` 相同。示例：

@CachePut(value = "emp", key = "targetClass + #p0")
        public User updata(User user) { 
            userMapper.updata(job);
            return job;
        }
    
        @Cacheable(value = "emp", key = "targetClass +#p0")//清空缓存
        public User save(User user) { 
            userMapper.save(job);
            return job;
        }

查看它的其它属性

## 组合@Caching ##

有时候我们可能组合多个`Cache`注解使用，此时就需要`@Caching`组合多个注解标签了。

@Caching(cacheable = { 
                @Cacheable(value = "emp",key = "#p0"),
                ...
        },
        put = { 
                @CachePut(value = "emp",key = "#p0"),
                ...
        },evict = { 
                @CacheEvict(value = "emp",key = "#p0"),
                ....
        })
        public User save(User user) { 
            ....
        }