概述

这里用一个示例通过注解的方式整合 Spring 和 Redis，要特别注意 Redis 缓存和数据库一致性的问题。

Redis 和数据库读

数据缓存往往会在 Redis 上设置超时时间，当设置 Redis 的数据超时后， Redis 就没法读出数据了，这个时候就会触发程序读取数据库，然后将读取的数据库数据写入 Redis （此时会给 Redis 重设超时时间），这样程序在读取的过程中就能按一定的时间间隔刷新数据了。

流程图大致如下：

伪代码大致如下

public Data  getData(args){
// 从Redis中获取数据
Data data = getDataFromRedis(key);
// 如果redis中没有数据，从db中加载并写入redis
if( data = null)
    // 从数据库中读取数据
  data = getDataFromDataBase();
    // 重新写入 Redis，以便后续从Redis中读取
  write2Redis(key ,data);
  // 设置 Re dis 的超时时间为 5 分钟
    setRedisExpireTime(5);
  }
}

上面的伪代码完成了上图所描述的过程。这样每当读取 Redis 数据超过 5 分钟， Redis就不能读到超时数据了，只能重新从 Redis 中读取，保证了一定的实时性，也避免了多次访问数据库造成的系统性能低下的情况。

Redis和数据库写

写操作要考虑数据一致的问题，尤其是那些重要的业务数据，所以首先应该考虑从数据库中读取最新的数据，然后对数据进行操作，最后把数据写入 Redis 缓存中.

流程大致如下

写入业务数据，先从数据库中读取最新数据，然后进行业务操作，更新业务数据到数据库后，再将数据刷新到 Redis 缓存中，这样就完成了一次写操作。这样的操作就能避免将脏数据写入数据库中，这类问题在操作时要注意。

伪代码大致如下

public  void writeData(args){
  //从数据库里读取最新数据
   DataObject dataObject = getFromDataBase(args);
  //执行业务逻辑
   execLogic(dataObject);
  //更新数据库数据
  updateDataBase(dataObject );
  // 刷新 Red is 缓存
  updateRedisData(dataObject ) ;
}

上面的伪代码完成了上图所描述的过程。首先，从数据库中读取最新的数据，以规避缓存中的脏数据问题，执行了逻辑，修改了部分业务数据。然后，把这些数据保存到数据库里，最后，刷新这些数据到 Redis 中。

使用 Spring 缓存机制整合 Redis

工程结构

用到了

Spring
Spring Cache
Mybatis
Redis

需要将上述3者整合起来

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>ssm_anno_redis</groupId>
  <artifactId>ssm_anno_redis</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>ssm_anno_redis</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- 1.日志 -->
    <!-- 实现slf4j接口并整合 -->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.1</version>
    </dependency>
    <!-- 2.数据库 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>2.5.0</version>
    </dependency>
    <!-- DAO: MyBatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.2</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!-- 4.Spring -->
    <!-- 1)Spring核心 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
    </dependency>
    <!-- 2)Spring DAO层 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
    </dependency>
    <!-- redis客户端:Jedis -->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!-- spring-data-redis -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.8.15.RELEASE</version>
    </dependency>
  </dependencies>
  <!-- 在dependencyManagement中引入spring-framework-bom来确保所有的spring模块都使用统一的版本. 
    添加spring-framework-bom后，就不需要配置每个依赖的版本号了，方便管理与升级 -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-framework-bom</artifactId>
        <version>4.3.9.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <build>
    <finalName>ssm_anno_redis</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

DB Script & Redis Address

mysql 部署在CentOS6.5 ，版本为5.7 ，地址为192.168.31.66 。同样的Redis也部署在这台主机上，单节点。

drop database artisan;
create database artisan;
use artisan;
create table t_role (
id int(12) auto_increment,
role_name varchar(60) not null,
note varchar(256) null,
primary key(id)
);

POJO类

package com.artisan.ssm_redis.domain;
import java.io.Serializable;
public class Role implements Serializable {
  private static final long serialVersionUID = -4381384997344901377L;
  private Long id;
  private String roleName;
  private String note;
  /**** setter and getter ****/
  public Long getId() {
    return id;
  }
  public void setId(Long id) {
    this.id = id;
  }
  public String getRoleName() {
    return roleName;
  }
  public void setRoleName(String roleName) {
    this.roleName = roleName;
  }
  public String getNote() {
    return note;
  }
  public void setNote(String note) {
    this.note = note;
  }
  @Override
  public String toString() {
    return "Role [id=" + id + ", roleName=" + roleName + ", note=" + note + "]";
  }
}

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

搭建MyBatis环境

RoleMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper  
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.artisan.ssm_redis.dao.RoleDao">
  <select id="getRole" resultType="com.artisan.ssm_redis.domain.Role">
    select id, role_name as
    roleName, note from t_role where id = #{id}
  </select>
  <delete id="deleteRole">
    delete from t_role where id=#{id}
  </delete>
  <insert id="insertRole" parameterType="com.artisan.ssm_redis.domain.Role"
    useGeneratedKeys="true" keyProperty="id">
    insert into t_role (role_name, note) values(#{roleName}, #{note})
  </insert>
  <update id="updateRole" parameterType="com.artisan.ssm_redis.domain.Role">
    update t_role set role_name = #{roleName}, note = #{note}
    where id = #{id}
  </update>
  <select id="findRoles" resultType="com.artisan.ssm_redis.domain.Role">
    select id, role_name as roleName, note from t_role
    <where>
      <if test="roleName != null">
        role_name like concat('%', #{roleName}, '%')
      </if>
      <if test="note != null">
        note like concat('%', #{note}, '%')
      </if>
    </where>
  </select>
</mapper>

RoleDao接口

Mapper映射文件完成后，需要一个 MyBatis 角色接口，以便使用这样的一个映射文件，

package com.artisan.ssm_redis.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import com.artisan.ssm_redis.domain.Role;
@Repository
public interface RoleDao {
  public Role getRole(Long id);
  public int deleteRole(Long id);
  public int insertRole(Role role);
  public int updateRole(Role role);
  public List<Role> findRoles(@Param("roleName") String roleName, @Param("note") String note);
}

注解＠Repository 表示它是一个持久层的接口。通过扫描和注解联合定义 DAO 层，就完成了mappe的内容。

Service层接口

定义角色服务接口（ RoleService ），因为要在接口实现类中加入 Spring 缓存注解，以驱动不同的行为，所里这里仅仅先将接口定义出来

package com.artisan.ssm_redis.service;
import java.util.List;
import com.artisan.ssm_redis.domain.Role;
public interface RoleService {
  public Role getRole(Long id);
  public int deleteRole(Long id);
  public Role insertRole(Role role);
  public int updateRole(Role role);
  public List<Role> findRoles(String roleName, String note);
  public int insertRoles(List<Role> roleList);
}

基于Java类的配置定义数据库和相关的扫描内容

RootConfig.java

package com.artisan.ssm_redis.config;
import java.io.IOException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;
@Configuration
// 定义Spring 扫描的包
@ComponentScan("com.artisan.ssm_redis*")
// 使用事务驱动管理器
@EnableTransactionManagement
// 实现接口TransactionManagementConfigurer，这样可以配置注解驱动事务
public class RootConfig implements TransactionManagementConfigurer {
  private DataSource dataSource = null;
  /**
   * 
   * 
   * @Title: initDataSource
   * 
   * @Description: 配置数据库
   * 
   * 
   * @return: DataSource
   * @throws IOException
   */
  @Bean(name = "dataSource")
  public DataSource initDataSource() throws IOException {
    if (dataSource != null) {
      return dataSource;
    }
    Properties props = new Properties();
    props.load(RootConfig.class.getClassLoader().getResourceAsStream("jdbc.properties"));
    props.setProperty("driverClassName", props.getProperty("jdbc.driver"));
    props.setProperty("url", props.getProperty("jdbc.url"));
    props.setProperty("username", props.getProperty("jdbc.username"));
    props.setProperty("password", props.getProperty("jdbc.password"));
    try {
      dataSource = BasicDataSourceFactory.createDataSource(props);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return dataSource;
  }
  /**
   * 
   * 
   * @Title: initSqlSessionFactory
   * 
   * @Description: 配置SqlSessionFactoryBean
   * 
   * 
   * @return: SqlSessionFactoryBean
   * @throws IOException
   */
  @Bean(name = "sqlSessionFactory")
  public SqlSessionFactoryBean initSqlSessionFactory() throws IOException {
    SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
    sqlSessionFactory.setDataSource(initDataSource());
    // 配置MyBatis配置文件
    Resource resource = new ClassPathResource("mybatis/mybatis-config.xml");
    sqlSessionFactory.setConfigLocation(resource);
    return sqlSessionFactory;
  }
  /**
   * 
   * 
   * @Title: initMapperScannerConfigurer
   * 
   * @Description: 通过自动扫描，发现MyBatis Mapper接口
   * 
   * 
   * @return: MapperScannerConfigurer Mapper扫描器
   */
  @Bean
  public MapperScannerConfigurer initMapperScannerConfigurer() {
    MapperScannerConfigurer msc = new MapperScannerConfigurer();
    // 扫描包
    msc.setBasePackage("com.artisan.ssm_redis");
    msc.setSqlSessionFactoryBeanName("sqlSessionFactory");
    // 区分注解扫描
    msc.setAnnotationClass(Repository.class);
    return msc;
  }
  /**
   * 实现接口方法，注册注解事务，当@Transactional 使用的时候产生数据库事务
   */
  @Override
  @Bean(name = "annotationDrivenTransactionManager")
  public PlatformTransactionManager annotationDrivenTransactionManager() {
    DataSourceTransactionManager transactionManager = null;
    try {
      transactionManager = new DataSourceTransactionManager();
      transactionManager.setDataSource(initDataSource());
    } catch (IOException e) {
      e.printStackTrace();
    }
    return transactionManager;
  }
}

在 SqlSessionFactoryBean 的定义中引入了关于 MyBatis 的一个配置文件mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration  
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  "http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
    <mappers>  
        <mapper resource="mapper/RoleMapper.xml"/>  
    </mappers>
</configuration>

写到这里就可以开始进行Dao和Service层的单元测试了，比较简单这里省略了先。。。

因为我们主要是整合Spring Cache和 Redis. 所以Spring Cache的基础知识请参阅我的专栏 Spring-Cache手札

Spring的缓存管理器

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

下面使用注解驱动RedisCacheManager 定义

package com.artisan.ssm_redis.config;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**** imports ****/
@Configuration
@EnableCaching
public class RedisConfig {
  @Bean(name = "redisTemplate")
  public RedisTemplate initRedisTemplate() {
    JedisPoolConfig poolConfig = new JedisPoolConfig();
    // 最大空闲数
    poolConfig.setMaxIdle(50);
    // 最大连接数
    poolConfig.setMaxTotal(100);
    // 最大等待毫秒数
    poolConfig.setMaxWaitMillis(20000);
    // 创建Jedis连接工厂
    JedisConnectionFactory connectionFactory = new JedisConnectionFactory(poolConfig);
    connectionFactory.setHostName("192.168.31.66");
    connectionFactory.setPort(6379);
    // 调用后初始化方法，没有它将抛出异常Cannot get Jedis connection
    connectionFactory.afterPropertiesSet();
    // 自定Redis序列化器
    RedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
    RedisSerializer stringRedisSerializer = new StringRedisSerializer();
    // 定义RedisTemplate，并设置连接工程
    RedisTemplate redisTemplate = new RedisTemplate();
    redisTemplate.setConnectionFactory(connectionFactory);
    // 设置序列化器
    redisTemplate.setDefaultSerializer(stringRedisSerializer);
    redisTemplate.setKeySerializer(stringRedisSerializer);
    redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
    redisTemplate.setHashKeySerializer(stringRedisSerializer);
    redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);
    return redisTemplate;
  }
  @Bean(name = "redisCacheManager")
  public CacheManager initRedisCacheManager(@Autowired RedisTemplate redisTempate) {
    RedisCacheManager cacheManager = new RedisCacheManager(redisTempate);
    // 设置超时时间为10分钟，单位为秒
    cacheManager.setDefaultExpiration(600);
    // 设置缓存名称
    List<String> cacheNames = new ArrayList<String>();
    cacheNames.add("redisCacheManager");
    cacheManager.setCacheNames(cacheNames);
    return cacheManager;
  }
}

@EnableCaching 表示 Spring IoC 容器启动了缓存机制。

对于 RedisTemplate 的定义实例和 XML 的方式差不多。

注意，在创建 Jedis 连接工厂(JedisConnectionFactory ）后，要自己调用其 afterPropertiesSet 方法，因为这里不是单独自定义一个 Spring Bean，而是在 XML方式中是单独自定义的 .这个类实现了 InitializingBean 接口，按照 Spring Bean 的生命周期,它会被 Spring IoC 容器自己调用，而这里的注解方式没有定义 Spring Bean，因此需要自己调用.

字符串定义了 key （包括 hash 数据结构），而值则使用了序列化，这样就能够保存 Java对象了。缓存管理器 RedisCacheManager 定义了默认的超时时间为 10 分钟，这样就可以在一定的时间间隔后重新从数据库中读取数据了，而名称则定义为 redisCacheManager，名称是为了方便后面注解引用的。

Service层整合缓存

package com.artisan.ssm_redis.service.impl;
import java.util.List;
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 org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.artisan.ssm_redis.dao.RoleDao;
import com.artisan.ssm_redis.domain.Role;
import com.artisan.ssm_redis.service.RoleService;
@Service
public class RoleServiceImpl implements RoleService {
  // 自动注入
  @Autowired
  private RoleDao roleDao;
  /**
   * 使用@Cacheable定义缓存策略 当缓存中有值，则返回缓存数据，否则访问方法得到数据 通过value引用缓存管理器，通过key定义键
   * 
   * @param id
   *            角色编号
   * @return 角色
   */
  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
  @Cacheable(value = "redisCacheManager", key = "'redis_role_'+#id")
  public Role getRole(Long id) {
    return roleDao.getRole(id);
  }
  /**
   * 使用@CachePut则表示无论如何都会执行方法，最后将方法的返回值再保存到缓存中
   * 使用在插入数据的地方，则表示保存到数据库后，会同期插入到Redis缓存中
   * 
   * @param role
   *            角色对象
   * @return 角色对象（会回填主键）
   */
  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
  @CachePut(value = "redisCacheManager", key = "'redis_role_'+#result.id")
  public Role insertRole(Role role) {
    roleDao.insertRole(role);
    return role;
  }
  /**
   * 使用@CachePut，表示更新数据库数据的同时，也会同步更新缓存
   * 
   * @param role
   *            角色对象
   * @return 影响条数
   */
  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
  @CachePut(value = "redisCacheManager", key = "'redis_role_'+#role.id")
  public int updateRole(Role role) {
    return roleDao.updateRole(role);
  }
}

因为 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 文件来监控整个过程：

log4j.rootLogger=DEBUG , stdout
log4j.logger.org.mybatis=DEBUG
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

写下单元测试来验证下

package com.artisan.ssm_redis.service;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.artisan.ssm_redis.config.RedisConfig;
import com.artisan.ssm_redis.config.RootConfig;
import com.artisan.ssm_redis.domain.Role;
public class RoleServiceTest {
  public static void main(String[] args) {
    // 使用注解Spring IoC容器
    ApplicationContext ctx = new AnnotationConfigApplicationContext(RootConfig.class, RedisConfig.class);
    // 获取角色服务类
    RoleService roleService = ctx.getBean(RoleService.class);
    Role role = new Role();
    role.setRoleName("role_name_1");
    role.setNote("role_note_1");
    // 插入角色
    roleService.insertRole(role);
    // 获取角色
    Role role2 = roleService.getRole(role.getId());
    System.out.println(role2.toString());
    // 更新角色
    role2.setNote("role_note_1_update");
    roleService.updateRole(role2);
    System.out.println(role2.toString());
    // 删除角色
    // roleService.deleteRole(role2.getId());
  }
}

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

23:59:14.151 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
23:59:14.161 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7674b62c]
23:59:14.171 [main] DEBUG org.mybatis.spring.transaction.SpringManagedTransaction - JDBC Connection [1168924571, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] will be managed by Spring
23:59:14.171 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.insertRole - ==>  Preparing: insert into t_role (role_name, note) values(?, ?) 
23:59:14.221 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.insertRole - ==> Parameters: role_name_1(String), role_note_1(String)
23:59:14.221 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.insertRole - <==    Updates: 1
23:59:14.231 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7674b62c]
23:59:14.321 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Opening RedisConnection
23:59:14.464 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection
23:59:14.464 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7674b62c]
23:59:14.464 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7674b62c]
23:59:14.474 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7674b62c]
23:59:14.474 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Initiating transaction commit
23:59:14.474 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Committing JDBC transaction on Connection [1168924571, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java]
23:59:14.474 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Resetting isolation level of JDBC Connection [1168924571, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to 4
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Releasing JDBC Connection [1168924571, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] after transaction
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Returning JDBC Connection to DataSource
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Creating new transaction with name [com.artisan.ssm_redis.service.impl.RoleServiceImpl.getRole]: PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED; ''
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Acquired Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] for JDBC transaction
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Changing isolation level of JDBC Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to 2
23:59:14.484 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Switching JDBC Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to manual commit
23:59:14.484 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Opening RedisConnection
23:59:14.484 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection
23:59:14.484 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Opening RedisConnection
23:59:14.494 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection
23:59:14.584 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Initiating transaction commit
23:59:14.584 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Committing JDBC transaction on Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java]
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Resetting isolation level of JDBC Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to 4
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Releasing JDBC Connection [1280429864, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] after transaction
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Returning JDBC Connection to DataSource
Role [id=30, roleName=role_name_1, note=role_note_1]
23:59:14.594 [main] DEBUG org.springframework.transaction.annotation.AnnotationTransactionAttributeSource - Adding transactional method 'com.artisan.ssm_redis.service.impl.RoleServiceImpl.updateRole' with attribute: PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED; ''
23:59:14.594 [main] DEBUG org.springframework.cache.annotation.AnnotationCacheOperationSource - Adding cacheable method 'updateRole' with attribute: [Builder[public int com.artisan.ssm_redis.service.impl.RoleServiceImpl.updateRole(com.artisan.ssm_redis.domain.Role)] caches=[redisCacheManager] | key=''redis_role_'+#role.id' | keyGenerator='' | cacheManager='' | cacheResolver='' | condition='' | unless='']
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Creating new transaction with name [com.artisan.ssm_redis.service.impl.RoleServiceImpl.updateRole]: PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED; ''
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Acquired Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] for JDBC transaction
23:59:14.594 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Changing isolation level of JDBC Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to 2
23:59:14.604 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Switching JDBC Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to manual commit
23:59:14.604 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
23:59:14.604 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@737a135b]
23:59:14.604 [main] DEBUG org.mybatis.spring.transaction.SpringManagedTransaction - JDBC Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] will be managed by Spring
23:59:14.604 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.updateRole - ==>  Preparing: update t_role set role_name = ?, note = ? where id = ? 
23:59:14.604 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.updateRole - ==> Parameters: role_name_1(String), role_note_1_update(String), 30(Long)
23:59:14.604 [main] DEBUG com.artisan.ssm_redis.dao.RoleDao.updateRole - <==    Updates: 1
23:59:14.604 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@737a135b]
23:59:14.604 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Opening RedisConnection
23:59:14.614 [main] DEBUG org.springframework.data.redis.core.RedisConnectionUtils - Closing Redis Connection
23:59:14.614 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@737a135b]
23:59:14.614 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@737a135b]
23:59:14.614 [main] DEBUG org.mybatis.spring.SqlSessionUtils - Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@737a135b]
23:59:14.614 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Initiating transaction commit
23:59:14.614 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Committing JDBC transaction on Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java]
23:59:14.614 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Resetting isolation level of JDBC Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] to 4
23:59:14.614 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Releasing JDBC Connection [90346768, URL=jdbc:mysql://192.168.31.66:3306/artisan?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT, UserName=root@192.168.31.137, MySQL Connector Java] after transaction
23:59:14.614 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Returning JDBC Connection to DataSource
Role [id=30, roleName=role_name_1, note=role_note_1_update]

从日志可以看到，先插入了一个角色对象，所以有 insert 语旬的执行，跟着可以看到Redis 连接的打开和关闭， Spring 将值保存到 Redis 中。

对于 getRole 方法，则没有看到 SQL的执行，因为使用＠Cacheable 注解后，它先在 Redis 上查找，找到数据就返回了，所以这里中断了我们本可以看到的 Redis 连接的闭合。

对于 updateRole 方法而言，则是先去执行SQL ，更新数据后，再执行 Redis 的命令，这样更新到数据库的数据就和 Redis 的数据同步了。

因为在缓存管理器中设置了超时时间为 10 分钟，所以如果10 分钟后再用相同的 id去调用 getRole 方法，它就会通过调用方法将数据从数据库中取回了。这里可自行验证。

继续看删除和其他的方法

  /**
   * 使用@CacheEvict删除缓存对应的key
   * 
   * @param id
   *            角色编号
   * @return 返回删除记录数
   */
  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
  @CacheEvict(value = "redisCacheManager", key = "'redis_role_'+#id")
  public int deleteRole(Long id) {
    return roleDao.deleteRole(id);
  }

在方法执行完成后会移除对应的缓存，也就是还可以从方法内读取到缓存服务器中的数据。如果属性 beforelnvocation 声明为 true，则在方法前删除缓存数据，这样就不能在方法中读取缓存数据了，只是这个值的默认值为 false，所以默认的情况下只会在方法后执行删除缓存。

不适用续存的方法：

  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
  public List<Role> findRoles(String roleName, String note) {
    return roleDao.findRoles(roleName, note);
  }

findRoles方法我们这里没加缓存，使用缓存的前提一一高命中率，由于这里根据角色名称和备注查找角色信息，该方法的返回值会根据查询条件而多样化，导致其不确定和命中率低下，对于这样的场景，使用缓存并不能有效提高性能，所以这样的场景，就不再使用缓存了。

自调用失效问题：

  @Override
  @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)  
  public int insertRoles(List<Role> roleList) {
      for (Role role : roleList) {
      // 同一类的方法调用自己方法，产生自调用[插入：失效]问题
          this.insertRole(role);
      }
      return roleList.size();
  }

在 insertRoles 方法中调用了同一个类中带有注解＠CachePut 的 insertRole 方法，然而 Spring 并没有把对应新增的角色保存到 Redis 缓存上，因为缓存注解也是基于 SpringAOP 实现的，对于 SpringAOP 的基础是动态代理技术，也就是只有代理对象的相互调用，AOP 才有拦截的功能，才能执行缓存注解提供的功能。而这里的自调用是没有代理对象存在的，所以其注解功能也就失效了。

Redis-20Spring缓存机制整合Redis

概述

Redis 和数据库读

Redis和数据库写

使用 Spring 缓存机制整合 Redis

工程结构

pom.xml

DB Script & Redis Address

POJO类

搭建MyBatis环境

RoleMapper.xml

RoleDao接口

Service层接口

基于Java类的配置定义数据库和相关的扫描内容

Spring的缓存管理器

Service层整合缓存

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Redis-20Spring缓存机制整合Redis

概述

Redis 和数据库读

Redis和数据库写

使用 Spring 缓存机制整合 Redis

工程结构

pom.xml

DB Script & Redis Address

POJO类

搭建MyBatis环境

RoleMapper.xml

RoleDao接口

Service层接口

基于Java类的配置定义数据库和相关的扫描内容

Spring的缓存管理器

Service层整合缓存

热门文章

最新文章

相关课程

相关电子书

相关实验场景