spring boot使用redis管理缓存

1. redis简介

Redis是目前业界使用最广泛的内存数据存储。相比memcached，Redis支持更丰富的数据结构，例如hashes, lists, sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景。本文介绍Redis在Spring Boot中两个典型的应用场景。

2. widows版的安装
   安装指导

3. Springboot与redis的兼容性

Redis可以无缝的集成进Spring的缓存系统，自动绑定@Cacheable,
@CacheEvict等缓存注解。这句话是重点，意味着稍微配几个参数就能用了。

使用redis管理缓存三步曲

• 引入依赖包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

• application.yml 添加配置文件

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

• 添加配置

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;


@Configuration
@EnableCaching
public class CachingConfigurer extends CachingConfigurerSupport {

   /**
    * 配置redis的key值生成策略
    * @return
    */
   public KeyGenerator keyGenerator(){
      return new KeyGenerator() {
         @Override
         public Object generate(Object o, Method method, Object... objects) {
            StringBuffer buffer = new StringBuffer();
            buffer.append(o.getClass().getName());
            buffer.append(method.getName());
            for(Object obj:objects){
               buffer.append(obj.toString());
            }
            return buffer.toString();
         }
      };
   }

	/**
	* 这是根据需求情况配置，可不配该项
	*/
   @Bean
   public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
      RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
      config = config.entryTtl(Duration.ofMinutes(60*60*24*4));


      // 设置一个初始化的缓存空间set集合
      Set<String> cacheNames =  new HashSet<>();
      cacheNames.add("order_pay");

      // 对每个缓存空间应用不同的配置
      Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
      configMap.put("order_pay",  config.entryTtl(Duration.ofSeconds(60*60*24*4)));
      RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                                                        .initialCacheNames(cacheNames)
                                                        .withInitialCacheConfigurations(configMap)
                                                        .build();
      return cacheManager;
   }

	/**
	* 这是根据需求情况配置，可不配该项。序列化策略
	*/
   @Bean
   public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
      RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<Object,Object>();
      //使用Springboot中在application中的配置
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      //开启事务注解
      redisTemplate.setEnableTransactionSupport(true);
      //使用String格式序列化键值
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
      redisTemplate.setKeySerializer(stringRedisSerializer);
      redisTemplate.setHashKeySerializer(stringRedisSerializer);
      //使用json格式序列化value值
      Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
         new Jackson2JsonRedisSerializer<>(Object.class);
      ObjectMapper objectMapper = new ObjectMapper();
      objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
      objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
      jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
      redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
      redisTemplate.afterPropertiesSet();
      return redisTemplate;
   }

}

可以用了，测试

@RestController
public class UserController {

    @RequestMapping("/getUser")
    @Cacheable(value="user-key")
    public User getUser() {
        User user=new User("aa@126.com", "aa", "aa123456", "aa","123");
        System.out.println("若下面没出现“无缓存的时候调用”字样且能打印出数据表示测试成功");
        return user;
    }
}