SpringBoot2.x整合Redis

SpringBoot2.x整合Redis

引入Redis依赖

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

配置application-redis.yml

spring:
  redis:
    # Redis数据库索引（默认为0） 这里就是db(0)
    database: 0
    # Redis服务器地址
    host: localhost
    # Redis服务器连接端口
    port: 6379

    jedis:
      pool:
        # 连接池最大连接数（使用负值表示没有限制）   2.0区别  1.0+使用的是 spring.redis.pool.max-acitive
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 2.0区别
        max-wait: -1
        # 连接池中的最大空闲连接                       2.0区别
        max-idle: 8
        # 连接池中的最小空闲连接                       2.0区别
        min-idle: 0

然后再主application.yml中引入application-reids.yml

spring:
  profiles:
    include:
      - redis

写一个redis的配置类

/**
 * redis配置类
 */
@Configuration
@EnableCaching  //开启redis缓存注解
public class RedisConfig {

    private StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

    private GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

    /**
     * @description TODO 缓存key前缀
     */
    private static final String keyPrefix = "CACHE:";

    /**
     * 缓存生成key的策略 需要继承CachingConfigurerSupport
     */
    /*@Bean
    @Override
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringJoiner joiner = new StringJoiner(":",keyPrefix,"");
            joiner.add(target.getClass().getSimpleName());
            joiner.add(method.getName());

            ObjectMapper objectMapper = new ObjectMapper();
            for (Object param : params) {

                //joiner.add(JSONObject.toJSONString(param));
                try {
                    joiner.add(objectMapper.writeValueAsString(param));
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
            }
            return joiner.toString();
        };
    }*/

    /**
     * 管理缓存
     */
    @Bean
    public RedisCacheManager cacheManager(LettuceConnectionFactory factory) {
        //缓存配置对象
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                //设置缓存的默认超时时间：30分钟
                .entryTtl(Duration.ofMinutes(30L))
                //如果是空值，不缓存
                .disableCachingNullValues()
                //设置key序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(stringRedisSerializer))
                //设置value序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer));

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory))
                .cacheDefaults(cacheConfig).transactionAware().build();
    }


    /**
     * redisTemplate 模板
     *
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(connectionFactory);

        //key hashMap的key序列化
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        //value hashMap的value序列化
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

方法一、使用相关注解

@Cacheable 缓存

加上此注解，将方法的运行结果进行缓存，以后再要相同的数据，直接从缓存中获取，不用调用方法。

一些属性：

• cacheNames/value：指定缓存组件的名字，值是可以是一个数组，就是对此缓存组件取多个名字。

• key：缓存数据使用的key，可以用它来指定。默认是使用方法参数的值；还可以方法的返回值

  编写SpEl：#id ->参数id的值 #a0 #p0 #root.args[0]

• keyGenerator：key的生成器，可以自己指定key的生成器的组件id

  注意：key与keyGenerator，二选一

• condition：指定符合条件的情况下缓存。

• unless：否定缓存。条件满足的情况下，方法的返回值不会被缓存。

• sync：是否使用异步模式。

@CachePut 更新缓存

既调用方法，又更新缓存数据。先调用目标方法，将目标方法结果缓存起来

@CacheEvict 缓存清除

• key：指定清除的数据
• allEntries=true 指定清除这个缓存中的所有数据
• beforeInvocation=true 缓存清除是否在方法执行之前执行。默认在方法执行之后执行。

@CacheConfig 注解

用于类上

• cacheNames：定义缓存组件的名字。

注意

在本内部类调用此注解的方法不生效，因为@Cacheable 由AOP 实现，所以，如果该方法被其它注解切入，当缓存命中的时候，则其它注解不能正常切入并执行，@Before 也不行，当缓存没有命中的时候，其它注解可以正常工作。

方法二、使用RedisTemplate

为了方便操作，写一个业务RedisService，对RedisTemplate的方法再封装一下。

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /*public RedisService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }*/

    /**
     * 判断键是否存在
     * @param key
     * @return
     */
    public boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获取指定key的值
     * @param key
     * @return
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 设置缓存
     * @param key
     * @param time 存在时间 单位 秒
     * @param value
     * @return
     */
    public boolean set(String key, long time, Object value) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value);
        }
        return true;
    }

    /**
     * 删除key
     * @param key
     */
    public void del(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 删除所有key
     */
    public void flushAll(){
        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);
    }
}