Spring整合Redis详细步骤

曾经终败给现在 2024-04-05 07:30 66阅读 0赞

教程前面大部分使用的是 XML 的方式整合 Redis，现在用注解驱动的方式来使用 Redis。和数据库事务一样，Spring 提供了缓存的管理器和相关的注解来支持类似于 Redis 这样的键值对缓存。

### 准备测试环境 ###

首先，定义一个简单的角色 POJO，代码如下所示。

> 1.  `package com.pojo;`
> 2.  `import java.io.Serializable;`
> 3.  `public class Role implements Serializable {`
> 4.  `private static final long serialVersionUID = 3447499459461375642L;`
> 5.  `private long id;`
> 6.  `private String roleName;`
> 7.  `private String note;`
> 8.  `// 省略setter和getter方法`
> 9.  `}`

注意，该类实现了 Serializable 接口，这说明这个类支持序列化，这样就可以通过 Spring 的序列化器，将其保存为对应的编码，缓存到 Redis 中，也可以通过 Redis 读回那些编码，反序列化为对应的 Java 对象。

接下来是关于 MyBatis 的开发环境，这样我们就可以操作数据库了。创建 RoleMapper.xml，代码如下所示。

> 1.  `<?xml version="1.0" encoding="UTF-8"?>`
> 2.  `<!DOCTYPE mapper`
> 3.  `PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"`
> 4.  `"http://mybatis.org/dtd/mybatis-3-mapper.dtd">`
> 5.  `<mapper namespace="com.dao.RoleDao">`
> 6.  `<select id="getRole" resultType="com.pojo.Role">`
> 7.  `select id, role_name as`
> 8.  `roleName, note from t_role where id = #{id}`
> 9.  `</select>`
> 10. `<delete id="deleteRole">`
> 11. `delete from t_role where id=#{id}`
> 12. `</delete>`
> 13. `<insert id="insertRole" parameterType="com.pojo.Role"`
> 14. `useGeneratedKeys="true" keyProperty="id">`
> 15. `insert into t_role (role_name,`
> 16. `note) values(#{roleName}, #{note})`
> 17. `</insert>`
> 18. `<update id="updateRole" parameterType="com.pojo.Role">`
> 19. `update t_role set`
> 20. `role_name = #{roleName}, note = #{note} where id = #{id}`
> 21. `</update>`
> 22. `<select id="findRoles" resultType="com.pojo.Role">`
> 23. `select id, role_name as roleName, note from t_role`
> 24. `<where>`
> 25. `<if test="roleName != null">`
> 26. `role_name like concat('%', #{roleName}, '%')`
> 27. `</if>`
> 28. `<if test="note != null">`
> 29. `note like concat ('%', #{note},'%')`
> 30. `</if>`
> 31. `</where>`
> 32. `</select>`
> 33. `</mapper>`

然后，需要一个 MyBatis 角色接口，以便使用这样的一个映射文件，代码如下所示。

> 1.  `package com.dao;`
> 2.  `import java.util.List;`
> 3.  `import org.apache.ibatis.annotations.Param;`
> 4.  `import com.pojo.Role;`
> 5.  `public interface RoleDao {`
> 6.  `public Role getRole(Long id);`
> 7.  `public int deleteRole(Long id);`
> 8.  `public int insertRole(Role role);`
> 9.  `public int updateRole(Role role);`
> 10. `public List<Role> findRoles(@Param("roleName") String roleName, @Param("note") String note);`
> 11. `}`

注解 @Repository 表示它是一个持久层的接口。通过扫描和注解联合定义 DAO 层，就完成了映射器方面的内容。定义角色服务接口（RoleService），代码如下所示，不过服务接口实现类会在后面谈起，因为它需要加入 Spring 缓存注解，以驱动不同的行为。

> 1.  `package com.service;`
> 2.  `import java.util.List;`
> 3.  `import com.pojo.Role;`
> 4.  `public interface RoleService {`
> 5.  `public Role getRole(Long id);`
> 6.  `public int deleteRole(Long id);`
> 7.  `public Role insertRole(Role role);`
> 8.  `public int updateRole(Role role);`
> 9.  `public List<Role> findRoles(String roleName, String note);`
> 10. `}`

通过 Java 配置定义数据库和相关的扫描内容，代码如下所示。

> 1.  `package com.config;`
> 2.  `import java.util.Properties;`
> 3.  `import javax.sql.DataSource;`
> 4.  `import org.apache.commons.dbcp.BasicDataSourceFactory;`
> 5.  `import org.aspectj.apache.bcel.Repository;`
> 6.  `import org.mybatis.spring.SqlSessionFactoryBean;`
> 7.  `import org.mybatis.spring.mapper.MapperScannerConfigurer;`
> 8.  `import org.springframework.context.annotation.Bean;`
> 9.  `import org.springframework.context.annotation.ComponentScan;`
> 10. `import org.springframework.context.annotation.Configuration;`
> 11. `import org.springframework.core.io.ClassPathResource;`
> 12. `import org.springframework.core.io.Resource;`
> 13. `import org.springframework.transaction.PlatformTransactionManager;`
> 14. `import org.springframework.transaction.annotation.EnableTransactionManagement;`
> 15. `import org.springframework.transaction.annotation.TransactionManagementConfigurer;`
> 16. `@Configuration`
> 17. `// 定义Spring扫描的包`
> 18. `@ComponentScan("com.*")`
> 19. `// 使用事务驱动管理器`
> 20. `@EnableTransactionManagement`
> 21. `// 实现接口 TransactionManagementConfigurer，这样可以配置注解驱动事务`
> 22. `public class RootConfig implements TransactionManagementConfigurer {`
> 23. `private DataSource dataSource = null;`
> 24. `/**`
> 25. `* 配置数据库`
> 26. `*`
> 27. `* @return数据连接池`
> 28. `*/`
> 29. `@Bean(name = "dataSource")`
> 30. `public DataSource initDataSource() {`
> 31. `if (dataSource != null) {`
> 32. `return dataSource;`
> 33. `}`
> 34. `Properties props = new Properties();`
> 35. `props.setProperty("driverClassName", "com.mysql.jdbc.Driver");`
> 36. `props.setProperty("url", "jdbc:mysql://localhost:3306/redis");`
> 37. `props.setProperty("username", "root");`
> 38. `props.setProperty("password", "1128");`
> 39. `try {`
> 40. `dataSource = BasicDataSourceFactory.createDataSource(props);`
> 41. `} catch (Exception e) {`
> 42. `e.printStackTrace();`
> 43. `}`
> 44. `return dataSource;`
> 45. `}`
> 46. `/**`
> 47. `* 配置 SqlSessionFactoryBean`
> 48. `*`
> 49. `* @return SqlSessionFactoryBean`
> 50. `*/`
> 51. `@Bean(name = "SqlSessionFactory")`
> 52. `public SqlSessionFactoryBean initSqlSessionFactory() {`
> 53. `SqlSessionFactoryBean SqlSessionFactory = new SqlSessionFactoryBean();`
> 54. `SqlSessionFactory.setDataSource(initDataSource());`
> 55. `// 配置MyBatis配置文件`
> 56. `Resource resource = new ClassPathResource("mybatis/mybatis-config.xml");`
> 57. `SqlSessionFactory.setConfigLocation(resource);`
> 58. `return SqlSessionFactory;`
> 59. `}`
> 60. `/**`
> 61. `* 通过自动扫描，发现MyBatis Mapper接口`
> 62. `*`
> 63. `* @return Mapper 扫描器`
> 64. `*/`
> 65. `@Bean`
> 66. `public MapperScannerConfigurer initMapperScannerConfigurer() {`
> 67. `MapperScannerConfigurer msc = new MapperScannerConfigurer();`
> 68. `// 扫描包`
> 69. `msc.setBasePackage("com.*");`
> 70. `msc.setSqlSessionFactoryBeanName("SqlSessionFactory");`
> 71. `// 区分注解扫描`
> 72. `msc.setAnnotationClass(Repository.class);`
> 73. `return msc;`
> 74. `}`
> 75. `/**`
> 76. `* 实现接口方法，注册注解事务，当@Transactional使用的时候产生数据库事务`
> 77. `*/`
> 78. `@Override`
> 79. `@Bean(name = "annotationDrivenTransactionManager")`
> 80. `public PlatformTransactionManager annotationDrivenTransactionManager() {`
> 81. `DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();`
> 82. `transactionManager.setDataSource(initDataSource());`
> 83. `return transactionManager;`
> 84. `}`
> 85. `}`

在 SqlSessionFactoryBean 的定义中引入了关于 MyBatis 的一个配置文件——mybatis-config.xml，它放在源码的 mybatis 目录之下，它的作用是引入 RoleMapper.xml，这里笔者放在目录 com/dao 下，代码如下所示。

> 1.  `<?xml version="1.0" encoding="utf-8"?>`
> 2.  `<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"`
> 3.  `"http://mybatis.org/dtd/mybatis-3-config.dtd">`
> 4.  `<configuration>`
> 5.  `<mappers>`
> 6.  `<mapper resource="com/dao/RoleMapper.xml" />`
> 7.  `</mappers>`
> 8.  `</configuration>`

这样测试只要一个 RoleService 实现类就可以了，这个类的实现就是我们后面所需要讨论的主要的内容，不过在此之前要先了解 Spring 的缓存管理器。

### Spring 的缓存管理器 ###

在 Spring 项目中它提供了接口 CacheManager 来定义缓存管理器，这样各个不同的缓存就可以实现它来提供管理器的功能了，而在 spring-data-redis.jar 包中实现 CacheManager 接口的则是 RedisCacheManager，因此要定义 RedisCacheManager 的 Bean，不过在此之前要先定义 RedisTemplate。

下面使用注解驱动 RedisCacheManager 定义，代码如下所示。

> 1.  `package com.config;`
> 2.  `import java.util.ArrayList;`
> 3.  `import java.util.List;`
> 4.  `import org.springframework.beans.factory.annotation.Autowired;`
> 5.  `import org.springframework.cache.CacheManager;`
> 6.  `import org.springframework.cache.annotation.EnableCaching;`
> 7.  `import org.springframework.context.annotation.Bean;`
> 8.  `import org.springframework.context.annotation.Configuration;`
> 9.  `import org.springframework.data.redis.cache.RedisCacheManager;`
> 10. `import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;`
> 11. `import org.springframework.data.redis.core.RedisTemplate;`
> 12. `import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;`
> 13. `import org.springframework.data.redis.serializer.RedisSerializer;`
> 14. `import org.springframework.data.redis.serializer.StringRedisSerializer;`
> 15. `import redis.clients.jedis.JedisPoolConfig;`
> 16. `@Configuration`
> 17. `@EnableCaching`
> 18. `public class RedisConfig {`
> 19. `@Bean(name = "redisTemplate")`
> 20. `public RedisTemplate initRedisTemplate() {`
> 21. `JedisPoolConfig poolConfig = new JedisPoolConfig();`
> 22. `// 最大空闲数`
> 23. `poolConfig.setMaxIdle(50);`
> 24. `// 最大连接数`
> 25. `poolConfig.setMaxTotal(100);`
> 26. `// 最大等待亳秒数`
> 27. `poolConfig.setMaxWaitMillis(20000);`
> 28. `// 创建Jedis连接工厂`
> 29. `JedisConnectionFactory connectionFactory = JedisConnectionFactory(poolConfig);`
> 30. `connectionFactory.setHostName("localhost");`
> 31. `connectionFactory.setPort(6379);`
> 32. `// 调用后初始化方法，没有它将抛出异常`
> 33. `connectionFactory.afterPropertiesSet();`
> 34. `// 自定Redis序列化器`
> 35. `RedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();`
> 36. `RedisSerializer stringRedisSerializer = new StringRedisSerializer();`
> 37. `// 定义RedisTemplate，并设置连接工程`
> 38. `RedisTemplate redisTemplate = new RedisTemplate();`
> 39. `redisTemplate.setConnectionFactory(connectionFactory);`
> 40. `// 设置序列化器`
> 41. `redisTemplate.setDefaultSerializer(stringRedisSerializer);`
> 42. `redisTemplate.setKeySerializer(stringRedisSerializer);`
> 43. `redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);`
> 44. `redisTemplate.setHashKeySerializer(stringRedisSerializer);`
> 45. `redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);`
> 46. `return redisTemplate;`
> 47. `}`
> 48. `@Bean(name = "redisCacheManager")`
> 49. `public CacheManager initRedisCacheManager(@Autowired RedisTemplate redisTempate) {`
> 50. `RedisCacheManager cacheManager = new RedisCacheManager(redisTempate);`
> 51. `// 设置超时时间为10分钟，单位为秒`
> 52. `cacheManager.setDefaultExpiration(600);`
> 53. `// 设置缓存名称`
> 54. `List<String> cacheNames = new ArrayList<String>();`
> 55. `cacheNames.add("redisCacheManager");`
> 56. `cacheManager.setCacheNames(cacheNames);`
> 57. `return cacheManager;`
> 58. `}`
> 59. `}`

@EnableCaching 表示 Spring IoC 容器启动了缓存机制。对于 RedisTemplate 的定义实例和 XML 的方式差不多。注意，在创建 Jedis 连接工厂（JedisConnectionFactory）后，要自己调用其 afterPropertiesSet 方法，因为这里不是单独自定义一个 Spring Bean，而是在 XML 方式中是单独自定义的。

这个类实现了 InitializingBean 接口，按照 Spring Bean 的生命周期，我们知道它会被 Spring IoC 容器自己调用，而这里的注解方式没有定义 SpringBean，因此需要自己调用，这也是使用注解方式的不便之处——需要了解其内部的实现。

字符串定义了 key（包括 hash 数据结构），而值则使用了序列化，这样就能够保存 Java 对象了。

缓存管理器 RedisCacheManager 定义了默认的超时时间为 10 分钟，这样就可以在一定的时间间隔后重新从数据库中读取数据了，而名称则定义为 redisCacheManager，名称是为了方便后面注解引用的。

如果在 XML 中使用缓存管理器，那也是可行的，首先要定义 RedisTemplate，这些已经在前面的章节中谈论过了，所以关于 RedisTemplate 的 XML 配置就不再重复阐述了，这里只定义 RedisCacheManager，使用 XML 定义缓存管理器代码如下所示。

> 1.  `<?xml version="1.0" encoding="UTF-8"?>`
> 2.  `<beans xmlns="http://www.springframework.org/schema/beans"`
> 3.  `xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"`
> 4.  `xmlns:p="http://www.springframework.org/schema/p"`
> 5.  `xmlns:cache="http://www.springframework.org/schema/cache"`
> 6.  `xsi:schemaLocation="http://www.springframework.org/schema/beans`
> 7.  `http://www.springframework.org/schema/beans/spring-beans.xsd`
> 8.  `http://www.springframework.org/schema/cache`
> 9.  `http://www.springframework.org/schema/cache/spring-cache.5.0.xsd`
> 10. `">`
> 11. ``
> 12. `<cache:annotation-driven cache-manager="redisCacheManager" />`
> 13. ``
> 14. `<bean id="redisCacheManager"`
> 15. `class="org.springframework.data.redis.cache.RedisCacheManager">`
> 16. ``
> 17. `<constructor-arg index="0" ref="redisTemplate" />`
> 18. ``
> 19. `<property name="defaultExpiration" value="600" />`
> 20. ``
> 21. `<property name="cacheNames">`
> 22. `<list>`
> 23. `<value>redisCacheManager</value>`
> 24. `</list>`
> 25. `</property>`
> 26. `</bean>`
> 27. `</beans>`

这样也可以配置好对应的缓存管理器。

### 缓存注解简介 ###

配置了缓存管理器之后，Spring 就允许用注解的方式使用缓存了，这里的注解有 4 个。XML 也可以使用它们，但是用得不多，我们就不再介绍了，还是以注解为主。首先简介一下缓存注解，如表 1 所示。

<table> 
 <thead> 
  <tr> 
   <th>注 解</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Cacheable</td> 
   <td>表明在进入方法之前，Spring 会先去缓存服务器中査找对应 key 的缓存值，如果找到缓存值，那么 Spring 将不会再调用方法，而是将缓存值读出，返回给调用者；如果没有找到缓存值，那么 Spring 就会执行你的方法，将最后的结果通过 key 保存到缓存服务器中</td> 
  </tr> 
  <tr> 
   <td>@CachePut</td> 
   <td>Spring 会将该方法返回的值缓存到缓存服务器中，这里需要注意的是，Spring 不会事先去缓存服务器中查找，而是直接执行方法，然后缓存。换句话说，该方法始终会被 Spring 所调用</td> 
  </tr> 
  <tr> 
   <td>@CacheEvict</td> 
   <td>移除缓存对应的 key 的值</td> 
  </tr> 
  <tr> 
   <td>@Caching</td> 
   <td>这是个分组注解，它能够同时应用于其他缓存的注解</td> 
  </tr> 
 </tbody> 
</table>

注解 @Cacheable 和 @CachePut 都可以保存缓存键值对，只是它们的方式略有不同，请注意二者的区别，它们只能运用于有返回值的方法中，而删除缓存 key 的 @CacheEvict 则可以用在 void 的方法上，因为它并不需要去保存任何值。

上述注解都能标注到类或者方法之上，如果放到类上，则对所有的方法都有效；如果放到方法上，则只是对方法有效。在大部分情况下，会放置到方法上。因为 @Cacheable 和 @CachePut 可以配置的属性接近，所以把它们归为一类去介绍，而 @Caching 因为不常用，就不介绍了。

一般而言，对于查询，我们会考虑使用 @Cacheable；对于插入和修改，我们会考虑使用 @CachePut；对于删除操作，我们会考虑使用 @CacheEvict。

### 注解@Cacheable和@CachePut ###

因为 @Cacheable 和 @CachePut 两个注解的配置项比较接近，所以这里就将这两个注解一并介绍了，它们的属性，如表 2 所示。

<table> 
 <thead> 
  <tr> 
   <th>属 性</th> 
   <th>配置类型</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>value</td> 
   <td>String[]</td> 
   <td>使用缓存的名称</td> 
  </tr> 
  <tr> 
   <td>condition</td> 
   <td>String</td> 
   <td>Spring 表达式，如果表达式返回值为 false，则不会将缓存应用到方法上，true 则会</td> 
  </tr> 
  <tr> 
   <td>key</td> 
   <td>String</td> 
   <td>Spring 表达式，可以通过它來计算对应缓存的 key</td> 
  </tr> 
  <tr> 
   <td>unless</td> 
   <td>String</td> 
   <td>Spring 表达式，如果表达式返回值为 true，则不会将方法的结果放到缓存上</td> 
  </tr> 
 </tbody> 
</table>

其中，因为 value 和 key 这两个属性使用得最多，所以先来讨论这两个属性。value 是一个数组，可以引用多个缓存管理器。

比如使用注解驱动 RedisCacheManager 定义代码中所定义的 RedisCacheManager，就可以引用它了，而对于 key 则是缓存中的键，它支持 Spring 表达式，通过 Spring 表达式就可以自定义缓存的 key。编写剩下的 RoleService 接口的实现类——RoleServiceImpl 的方法。

先了解一些 Spring 表达式和缓存注解之间的约定，通过这些约定去引用方法的参数和返回值的内容，使得其注入 key 所定义的 Spring 表达式的结果中，表达式值的引用如表 3 所示。

<table> 
 <thead> 
  <tr> 
   <th>表达式</th> 
   <th>描 述</th> 
   <th>备 注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>#root.args</td> 
   <td>定义传递给缓存方法的参数</td> 
   <td>不常用，不予讨论</td> 
  </tr> 
  <tr> 
   <td>#root.caches</td> 
   <td>该方法执行是对应的缓存名称，它是一个数组</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>#root.target</td> 
   <td>执行缓存的目标对象</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>#root.targetClass</td> 
   <td>目标对象的类，它是 #root.target.class 的缩写</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>#root.method</td> 
   <td>缓存方法</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>#root.methodName</td> 
   <td>缓存方法的名称，它是 #root.method.name 的缩写</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>#result</td> 
   <td>方法返冋结果值，还可以使用 Spring 表达式进一步读取其属性</td> 
   <td>请注意该表达式不能用于注解 @Cacheablc，因为该注解的方法可能不会被执行，这样返回值就无从谈起了</td> 
  </tr> 
  <tr> 
   <td>#Argument</td> 
   <td>任意方法的参数，可以通过方法本身的名称或者下标去定义</td> 
   <td>比如 getRole(Long id) 方法，想读取 id 这个参数，可以写为 #id，或者 #a0、#p0，笔者建议写为 #id，这样可读性高</td> 
  </tr> 
 </tbody> 
</table>

这样就方便使用对应的参数或者返回值作为缓存的 key 了。

RoleService 接口的实现类——RoleServiceImpl，它有 3 个方法，使用这个缓存可以启动缓存管理器来保存数据，代码如下所示。

> 1.  `package com.service;`
> 2.  `import java.util.List;`
> 3.  `import org.springframework.beans.factory.annotation.Autowired;`
> 4.  `import org.springframework.cache.annotation.CachePut;`
> 5.  `import org.springframework.cache.annotation.Cacheable;`
> 6.  `import org.springframework.stereotype.Service;`
> 7.  `import org.springframework.transaction.annotation.Isolation;`
> 8.  `import org.springframework.transaction.annotation.Propagation;`
> 9.  `import org.springframework.transaction.annotation.Transactional;`
> 10. `import com.dao.RoleDao;`
> 11. `import com.pojo.Role;`
> 12. `@Service`
> 13. `public class RoleServiceImpl implements RoleService {`
> 14. `//角色DAO，方便执行SQL`
> 15. `@Autowired`
> 16. `private RoleDao roleDao = null;`
> 17. `/**`
> 18. `* 使用@Cacheable定义缓存策略 当缓存中有值，则返回缓存数据，否则访问方法得到数据 通过value引用缓存管理器，通过key定义键`
> 19. `*`
> 20. `* @param id角色编号`
> 21. `* @return 角色`
> 22. `*/`
> 23. `@Override`
> 24. `@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)`
> 25. `@Cacheable(value = "redisCacheManager", key = "'redis_role_'+#id")`
> 26. `public Role getRole(Long id) {`
> 27. `return roleDao.getRole(id);`
> 28. `}`
> 29. `/**`
> 30. `* 使用@CachePut则表示无论如何都会执行方法，最后将方法的返回值再保存到缓存中 使用在插入数据的地方，则表示保存到数据库后，会同期插入Redis缓存中`
> 31. `*`
> 32. `* @param role角色对象 @return角色对象(会回填主键)`
> 33. `*/`
> 34. `@Override`
> 35. `@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)`
> 36. `@CachePut(value = "redisCacheManager", key = "'redis_role_'+#resuIt.id")`
> 37. `public Role insertRole(Role role) {`
> 38. `roleDao.insertRole(role);`
> 39. `return role;`
> 40. `}`
> 41. `/**`
> 42. `* 使用@CachePut，表示更新数据库数据的同时，也会同步更新缓存`
> 43. `*`
> 44. `* @param role角色对象`
> 45. `* @return影响条数`
> 46. `*/`
> 47. `@Override`
> 48. `@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)`
> 49. `@CachePut(value = "redisCacheManager", key = "'redis_role_' +#role. id")`
> 50. `public Role updateRole(Role role) {`
> 51. `roleDao.updateRole(role);`
> 52. `return role;`
> 53. `}`
> 54. `......`
> 55. `}`

因为 getRole 方法是一个查询方法，所以使用 @Cacheable 注解，这样在 Spring 的调用中，它就会先查询 Redis，看看是否存在对应的值，那么采用什么 key 去查询呢？

注解中的 key 属性，它配置的是 ‘redis*role*‘+\#id，这样 Spring EL 就会计算返回一个 key，比如参数 id 为 1L，其 key 计算结果就为 redis\_role\_1。以一个 key 去访问 Redis，如果有返回值，则不再执行方法，如果没有则访问方法，返回角色信息，然后通过 key 去保存数据到 Redis 中。

先执行 insertRole 方法才能把对应的信息保存到 Redis 中，所以采用的是注解 @CachePut。由于主键是由数据库生成，所以无法从参数中读取，但是可以从结果中读取，那么 \#result.id 的写法就会返回方法返回的角色 id。而这个角色 id 是通过数据库生成，然后由 MyBatis 进行回填得到的，这样就可以在 Redis 中新增一个 key，然后保存对应的对象了。

对于 updateRole 方法而言，采用的是注解 @CachePut，由于对象有所更新，所以要在方法之后更新 Redis 的数据，以保证数据的一致性。这里直接读取参数的 id，所以表达式写为 \#role.id，这样就可以引入角色参数的 id 了。在方法结束后，它就会去更新 Redis 对应的 key 的值了。

为此可以提供一个 log4j.properties 文件来监控整个过程：

> 1.  `# Global logging configuration`
> 2.  `log4j.rootLogger=DEBUG,stdout`
> 3.  `# MyBatis logging configuration...`
> 4.  `log4j.logger.com.mybatis=DEBUG`
> 5.  `# Console output...`
> 6.  `log4j.appender.stdout=org.apache.log4j.ConsoleAppender`
> 7.  `log4j.appender.stdout.layout=org.apache.log4j.PatternLayout`
> 8.  `log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n`

然后通过以下代码来测试缓存注解。

> 1.  `// 使用注解Spring IoC容器`
> 2.  `ApplicationContext ctx = new AnnotationConfigApplicationContext(RootConfig.class, RedisConfig.class);`
> 3.  `// 获取角色服务类`
> 4.  `RoleService roleService = ctx.getBean(RoleService.class);`
> 5.  `Role role = new Role();`
> 6.  `role.setRoleName("role_name_1");`
> 7.  `role.setNote("role_note_1");`
> 8.  `// 插入角色`
> 9.  `roleService.insertRole(role);`
> 10. `// 获取角色`
> 11. `Role getRole = roleService.getRole(role.getId());`
> 12. `getRole.setNote("role_note_1_update");`
> 13. `// 更新角色`
> 14. `roleService.updateRole(getRole);`

这里将关于数据库和 Redis 的相关配置通过注解 Spring IoC 容器加载进来，这样就可以用 Spring 操作这些资源了，然后执行插入、获取、更新角色的方法。