Spring Boot 项目中使用 Redis

Redis（REmote DIctionary Server）是一个由 Salvatore Sanfilippo 写的 key-value 存储系统。Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。它通常被称为数据结构服务器，因为值（value）可以是 字符串（String）、哈希（Hash）, 列表（list）、集合（sets）和 有序集合（sorted sets）等类型。

首先为项目添加 Redis 支持。

Gradle：

  // redis
  compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis', version: '2.1.1.RELEASE'
  compile group: 'redis.clients', name: 'jedis', version: '3.0.0'

Maven：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.0.0</version>
</dependency>

RedisConfig 类：

package com.charles.testlibrary.core.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.cache.RedisCacheWriter;
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.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

  /**
   * RedisTemplate配置.
   */
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate();
    redisTemplate.setConnectionFactory(factory);
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = this.getSerializer();
    // 设置key/value格式
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
  }

  /**
   * 设置redis缓存策略.
   *
   * @param factory 链接工厂
   * @return
   */
  @Bean
  public CacheManager cacheManager(RedisConnectionFactory factory) {
    return new RedisCacheManager(
            RedisCacheWriter.nonLockingRedisCacheWriter(factory),
            // 默认策略，未配置的 key 会使用这个 8小时
            this.getRedisCacheConfigurationWithTtl(60 * 60 * 48)
    //this.getRedisCacheConfigurationMap() // 指定 key 策略
    );
  }

  private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {

    Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
    redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(3000));
    redisCacheConfigurationMap.put("UserInfoListAnother",
            this.getRedisCacheConfigurationWithTtl(18000));

    return redisCacheConfigurationMap;
  }

  private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {

    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = this.getSerializer();
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
    redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
            RedisSerializationContext
                    .SerializationPair
                    .fromSerializer(jackson2JsonRedisSerializer)
    ).entryTtl(Duration.ofSeconds(seconds));

    return redisCacheConfiguration;
  }

  /**
   * 配置序列化策略.
   * @return 策略
   */
  public Jackson2JsonRedisSerializer getSerializer() {
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
            new Jackson2JsonRedisSerializer<>(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    return jackson2JsonRedisSerializer;
  }

}

RedisService 类：

package com.charles.testlibrary.core;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

  @Resource
  private RedisTemplate redisTemplate;

  /**
   * value设置.
   */
  public boolean set(String key, Object value) {
    boolean result = false;
    try {
      redisTemplate.opsForValue().set(key, value);
      result = true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }

  /**
   * value设置时效时间.
   */
  public boolean set(String key, Object value, Long expireTime) {
    boolean result = false;
    try {
      redisTemplate.opsForValue().set(key, value);
      redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
      result = true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }

  /**
   * value获取.
   */
  public Object get(String key) {
    return redisTemplate.opsForValue().get(key);
  }

  /**
   * 批量删除对应value.
   */
  public void remove(String... keys) {
    for (String key : keys) {
      if (exists(key)) {
        redisTemplate.delete(key);
      }
    }
  }

  /**
   * 判断缓存中是否有对应的value.
   */
  public boolean exists(String key) {
    return redisTemplate.hasKey(key);
  }

  /**
   * 哈希设置.
   */
  public void setHash(String key, Map<String, Object> value) {
    redisTemplate.opsForHash().putAll(key, value);
  }

  /**
   * 哈希获取.
   */
  public Map<Object, Object> getHash(String key) {
    return redisTemplate.opsForHash().entries(key);
  }

  /**
   * 列表设置.
   */
  public void setList(String key, List<Object> value) {
    redisTemplate.delete(key);
    redisTemplate.opsForList().leftPushAll(key, value);
  }

  /**
   * 列表获取.
   */
  public List<Object> getList(String key, int start, int end) {
    return redisTemplate.opsForList().range(key, start, end);
  }

  /**
   * 列表获取全部.
   */
  public List<Object> getList(String key) {
    return redisTemplate.opsForList().range(key, 0, -1);
  }

  /**
   * 集合设置.
   */
  public void setSet(String key, Set<Object> set) {
    redisTemplate.delete(key);
    redisTemplate.opsForSet().add(key, set);
  }

  /**
   * 集合获取.
   */
  public Set<Object> getSet(String key) {
    return redisTemplate.opsForSet().members(key);
  }

  /**
   * 有序集合设置.
   */
  public void setZSet(String key, Set<Object> set) {
    redisTemplate.delete(key);
    redisTemplate.opsForZSet().add(key, set);
  }

  /**
   * 有序集合获取.
   */
  public Set<Object> getZSet(String key, int start, int end) {
    return redisTemplate.opsForZSet().range(key, start, end);
  }

  /**
   * 有序集合获取全部.
   */
  public Set<Object> getZSet(String key) {
    return redisTemplate.opsForZSet().range(key, 0, -1);
  }
}

yml 配置：

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 8739
    password: 123456
    timeout: 5000
    lettuce:
      shutdown-timeout: 200
      pool:
        max-active: 500
        max-idle: 100
        min-idle: 50
        max-wait: 2000

使用方法：

package com.charles.testlibrary;

import static com.google.common.truth.Truth.assertThat;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.charles.testlibrary.core.RedisService;
import java.io.IOException;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import redis.clients.jedis.Jedis;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTests {

  @Autowired
  private RedisService redisService;
  @Resource
  private Jedis jedis;

  @Test
  public void testService() throws IllegalAccessException {
    redisService.set("name", "xyz");
    Object value = redisService.get("name");
    assertThat(value).isNotNull();
  }

  @Test
  public void testRedisMessage() throws IOException {
    String message = "{\"name\":\"xyz\"}";
    JsonNode jsonNode = new ObjectMapper().readTree(message);
    jedis.lpush("message-test", jsonNode.toString());
    String messages = jedis.rpop("message-test");
    assertThat(messages).isNotNull();
  }

}