Springboot-redis缓存使用

Springboot-redis缓存使用及解析

springboot的使用步骤如下：

1.引入redis的starter

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  <!--<version>2.1.2.RELEASE</version>-->
</dependency>

配置redis相关的starter之后，启动springboot默认启动的是RedisCacheConfiguration

同时，Springboot的RedisAutoConfiguration也自动生效了

//自动配置生效后就往容器中注入了RedisTemplate和StringRedisTemplate2个实例，用来操作Redis数据库
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
  //用来操作k-v都是对象的
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
	@Bean
	@ConditionalOnMissingBean
  用来操作k-v都是字符串的简易API
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

2.配置Redis的配置

常用的redis配置如下

spring:
  redis:
    host: 127.0.0.1       #Redis 地址 ===> 必须配置
    port: 6379            #Redis 端口号
    database: 0           #Redis 索引（0~15，默认为0）
    timeout: 1000         #Redis 连接的超时时间
    password: 123456      #Redis 密码，如果没有就默认不配置此参数
    lettuce:              #使用 lettuce 连接池
      pool:
        max-active: 20    #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1      #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0       #连接池中的最大空闲连接
        max-idle: 10      #连接池中的最小空闲连接
---
spring:
  redis:
    sentinel:             #哨兵配置
      master: "my-master"
      nodes: "192.168.2.11:6379,192.168.2.12:6379,192.168.2.13:6379"
    database: 0           #Redis 索引（0~15，默认为0）
    timeout: 1000         #Redis 连接的超时时间
    password: 123456      #Redis 密码，如果没有就默认不配置此参数  
    lettuce:              #使用 lettuce 连接池
      pool:
        max-active: 20    #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1      #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0       #连接池中的最大空闲连接
        max-idle: 10      #连接池中的最小空闲连接
---
spring:
  redis:
    cluster:              #redis 集群配置
      max-redirects: 5    #redis命令执行时最多转发次数
      nodes: "192.168.2.11:6379,192.168.2.12:6379,192.168.2.13:6379" 
    database: 0           #Redis 索引（0~15，默认为0）
    timeout: 1000         #Redis 连接的超时时间
    password: 123456      #Redis 密码，如果没有就默认不配置此参数  
    lettuce:              #使用 lettuce 连接池
      pool:
        max-active: 20    #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1      #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0       #连接池中的最大空闲连接
        max-idle: 10      #连接池中的最小空闲连接

3.在test模块中使用RedisTemplate和StringRedisTemplate来测试对Redis的操作

    @Autowired
    EmployeeMapper employeeMapper;
    @Autowired
    RedisTemplate<Object,Object> redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Test
    public void contextLoads() throws SQLException {

        stringRedisTemplate.opsForValue().set("shufang","hello");
        stringRedisTemplate.opsForValue().append("shufang","shuaige");
        stringRedisTemplate.opsForList().leftPush("l1","1");
        stringRedisTemplate.opsForHash().put("h1", 	"key1",employeeMapper.getById(1).toString());

    }

4.自定义配置类，来修改默认存储的jdk序列化模式->json

    /**
     * redis配置类还是需要依靠@EnableCaching相关的注解，才能自动将查询到的数据进行缓存
     * 要想生效还得在Manager中调用template
     * 我们可以参考RedisCacheConfiguration
     * 以下是redis中的存储格式
     * ["com.shufang.springbootcache.bean.Employee",{"Id":2,"lastName":"yangtao","email":null,"gender":null,"dId":null,"id":2}]
     */

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Employee> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Employee.class);

        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        // 配置序列化（解决乱码的问题）,过期时间30秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

RedisCache的配置类解析

@Configuration
@ConditionalOnClass(RedisConnectionFactory.class)
@AutoConfigureAfter(RedisAutoConfiguration.class)
@ConditionalOnBean(RedisConnectionFactory.class)
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class RedisCacheConfiguration {
//首先然后会给容器中注入RedisCacheManager的cache管理器，并进行默认的配置,此时SimpleCacheConfiguration就不生效了
//缓存就从之前的CurrentMap变成了Redis库
    @Bean
  public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
      ResourceLoader resourceLoader) {
    RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)
        .cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
    List<String> cacheNames = this.cacheProperties.getCacheNames();
    if (!cacheNames.isEmpty()) {
      builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
    }
    return this.customizerInvoker.customize(builder.build());
  }
  //然后后面就与ConcurrentCacheManager的调用方法差不多了