一、如何集成

首先，在 pom 文件新增 redis 依賴：

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

接著修改項目配置文件 application.properties，增加 redis 配置

# redis host
spring.redis.host=172.24.58.226
# redis port
spring.redis.port=6379

經(jīng)過上面簡單的兩步，即可在項目中使用 StringRedisTemplate 和 RedisTemplate<Object,Object>，因為從 Spring Boot 2.0 開始，Spring 容器是自動生成了這兩個實例，可以直接注入使用。如以下代碼片段：

@Autowired
private RedisTemplate<Object, Object> redisTemplate;

@Autowired
private StringRedisTemplate stringRedisTemplate;

...
  
// 通過 StringRedisTemplate 保存
stringRedisTemplate.opsForValue().set("strRedisTemplate", "test");

// 通過 RedisTemplate<Object, Object> 保存
tagRedisTemplate.opsForValue().set("tagRedisTemplate", 232);

二、存儲的 value 類型為字符串

在實際使用中，若保存的 value 類型為字符串，可以直接通過注入 StringRedisTemplate 進(jìn)行讀寫，如

@Autowired
private StringRedisTemplate stringRedisTemplate;

@RequestMapping("/redis")
public Object set(String name) {
  // 通過 StringRedisTemplate 寫入 redis
  stringRedisTemplate.opsForValue().set("iuiuu", name);

  // 通過 StringRedisTemplate 獲取
  String v = stringRedisTemplate.opsForValue().get("iuiuu");
  
  Map<String, Object> map = new HashMap<>();
  map.iuiuu("tag", v);
  return map;
}

三、存儲的 value 是一個對象

這種情況，也可以通過 StringRedisTemplate 進(jìn)行讀寫。不過，在寫入之前先將對象序列化為 JSON 字符串，然后再寫入 redis。讀取的時候，從 redis 獲取到的是是一個 JSON 字符串，需要反序列化相應(yīng)的對象。如以下代碼片段：

@Autowired
private StringRedisTemplate stringRedisTemplate;

@RequestMapping("/redis")
public Object set(String name) {
  Tag tag = new Tag()
    .setTagId(10001)
    .setTagName(name)
    .setCount(20)
    .setStatus(1);
  
  // 序列化為 JSON 字符串
  String str = JsonUtil.toJson(tag);
  // 寫入 redis
  stringRedisTemplate.opsForValue().set("iuiuu", str);

  // 從 redis 讀取
  String json = stringRedisTemplate.opsForValue().get("iuiuu");
  // 反序列化為 Tag 對象
  Tag t = JsonUtil.fromJson(json, Tag.class);
  
  Map<String, Object> map = new HashMap<>();
  map.put("tag", t);
  return map;
}

上面這種方式在讀取或?qū)懭氲臅r候，需要進(jìn)行序列化與反序列化，會有點繁瑣。我們還可以通過另一種簡潔的方式——RedisTemplate<Object, Object>，不過在實際項目中，大多數(shù)情況下，我們不會直接使用 RedisTemplate<Object, Object>，而是會對 key，value 進(jìn)行序列化，所以我們還需要新增一個配置類。以下示例新了配置類 RedisConfig：

/**
 * Redis 配置類
 * 
 * @author johnson lin
 * @date 2019/12/18 11:24 PM
 */
@Configuration
public class RedisConfig {
    @Bean("tagRedisTemplate")
    public RedisTemplate<String, Tag> tagRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Tag> template = new RedisTemplate<>();
        Jackson2JsonRedisSerializer<Tag> serializer = new Jackson2JsonRedisSerializer<>(Tag.class);
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

/**
 * 標(biāo)簽類
 *
 * @author johnson lin
 * @date 2019/12/18 11:08 PM
 */
public class Tag {
    /**
     * 標(biāo)簽Id
     */
    private int tagId;

    /**
     * 標(biāo)簽名稱
     */
    private String tagName;

    /**
     * 標(biāo)簽狀態(tài)：1-正常 2-暫不顯示
     */
    private int status;

    /**
     * 標(biāo)簽文章數(shù)
     */
    private int count;
    
    //省略 get、set
}

// 省略其它代碼...

@Autowired
@Qualifier("tagRedisTemplate")
private RedisTemplate<String, Tag> tagRedisTemplate;

@RequestMapping("/redis")
public Object set(String name) {
    Tag tag = new Tag()
            .setTagId(10001)
            .setTagName(name)
            .setCount(20)
            .setStatus(1);
    // 通過 RedisTemplate<String, Tag> 保存 Tag 實體類
    tagRedisTemplate.opsForValue().set("tagRedisTemplate", tag);

    // 通過 RedisTemplate<String, Tag> 獲取 Tag 實體類
    Tag newTag = tagRedisTemplate.opsForValue().get("tagRedisTemplate");

    Map<String, Object> map = new HashMap<>();
    map.put("newTag", newTag);
    return map;
}

四、StringRedisTemplate/RedisTemplate讀寫Redis示例

示例代碼如下：

@RequestMapping("/compared")
public Object compared(String name) {
    // 通過 StringRedisTemplate 保存 name
    stringRedisTemplate.opsForValue().set("strRedisTemplate", name);

    Tag tag = new Tag()
            .setTagId(10002)
            .setTagName(name)
            .setCount(20)
            .setStatus(1);

    // 通過 RedisTemplate<String, Tag> 保存 Tag 實體類
    tagRedisTemplate.opsForValue().set("key_tag", tag);

    // 通過 StringRedisTemplate 保存 Tag 實體，需先序列化為 JSON 字符串
    String str = JsonUtil.toJson(tag);
    stringRedisTemplate.opsForValue().set("key_str", str);


    // 通過 RedisTemplate<String, Tag> 獲取 Tag 實體類
    Tag t1 = tagRedisTemplate.opsForValue().get("key_tag");
    
    // 通過 StringRedisTemplate 獲取，需要反序列為對象
    String json = stringRedisTemplate.opsForValue().get("key_str");
    Tag t2 = JsonUtil.fromJson(json, Tag.class);

    return "succeed";
}

在 redis 中的值如下：

[iuiuu@226 ~]$ redis-cli 
127.0.0.1:6379> get key_tag
"{\"tagId\":10002,\"tagName\":\"History\",\"status\":1,\"count\":20}"
127.0.0.1:6379> get key_str
"{\"tagId\":10002,\"tagName\":\"History\",\"status\":1,\"count\":20}"
127.0.0.1:6379>

可以看到，這兩種方式將對象寫入到 redis 后，存儲的值其實是一樣的，都為 JSON 字符串。

本文示例代碼見 https://github.com/iuiuu/spring-boot-demos/tree/master/spring-boot-demos-redis