Redis——基于Spring的開發示例（連接、序列化、high/low api）

在前面的文章中，我們學習了有關 Redis 的幾乎所有的重點內容，都屬于理論內容，只有要掌握這些底層知識，這樣我們才能設計出良好的系統架構；而且當系統出現問題的時候，我們只有熟知了各種場景可能會發生什么問題，這樣才能快速的定位、排查以及解決問題

下面我們就來學習一下如何基于 SpringBoot 框架進行簡單的 Redis 的 API 進行開發

SpringBoot 集成 Redis 官網教程：

https://docs.spring.io/spring-data/redis/docs/2.3.4.RELEASE/reference/html/#reference

一、基本開發

我們這里就不演示基于 spring mvc 的 web 訪問方式，而是基于功能，簡單的進行代碼開發

1、建立spring boot專案

spring boot 專案中集成 redis

2、與vm中的redis建立連接

啟動redis實體：埠號 8888

//隨意創建一個目錄
mkdir springboot

//切換到此目錄
cd springboot/

//啟動一個redis實體，埠號為 8888
redis-server --port 8888

修改遠程訪問安全策略級別

//連接redis
redis-cli
//臨時修改安全策略，默認為 yes，修改為 no
config set protected-mode no

查看本機IP地址：192.168.159.111

[root@node01 ~]# ifconfig
eth0      Link encap:Ethernet  HWaddr 00:0C:29:F0:66:24  
          inet addr:192.168.159.111  Bcast:192.168.159.255  Mask:255.255.255.0

在 application.properties 組態檔中統一配置連接資訊

application.properties

spring.redis.host=192.168.159.111
spring.redis.port=8888

3、測驗連接

TestRedis.java

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入 template

    public void testRedis(){
        //設定data
        redisTemplate.opsForValue().set("hello", "china");

        //獲取data
        System.out.println(redisTemplate.opsForValue().get("hello"));
    }
}

DemoApplication.java

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        //獲取 ctx
        ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);

        //獲取容器中的bean物件
        TestRedis testRedis = ctx.getBean(TestRedis.class);

        testRedis.testRedis();
    }

}

運行結果：能夠連接到本地虛擬機的 redis 服務實體，并且能夠正常 set 和 get 資料

二、high/low API及序列化

在 Redis 支持的value型別中，其實可以分為兩類，一類就是單值型別，比如 string，還有一類就是復值型別，即hash，對于不同的型別的操作是不一樣的

1、high level api

RedisTemplate

在上面測驗中，我們已經把資料寫入了 Redis 中，所以 Redis 中應該存在資料，在 vm 中通過命令列獲取 key，發現出現亂碼，說明序列化的時候出現問題

127.0.0.1:8888> keys *
1) "\xac\xed\x00\x05t\x00\x05hello"

為什么會出現亂碼？我們知道 Redis 是針對很多語言提供服務的，所以它是二進制安全的，只存盤位元組陣列，任何一個客戶端都應該注意：我的資料是怎么變成的位元組陣列？是怎么進行的序列化？

上面使用的高階的 RedisTemplate 是面向基本的 JAVA 序列化方式，JAVA 序列化方式是要加一些東西，而不是字面意義上的編碼，所以在 key 前面多出了一些亂碼，

StringRedisTemplate

而我們在使用 Redis 的時候，更多的場景是基于 String 這種方式的，此時除了通用的 RedisTemplate，其實還有面向 String 的 StringRedisTemplate

TestRedis.java（使用StringRedisTemplate）

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入通用的 RedisTemplate

    @Autowired
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    public void testRedis(){
        //設定data
        stringRedisTemplate.opsForValue().set("hello01", "china");

        //獲取data
        System.out.println(stringRedisTemplate.opsForValue().get("hello"));
    }
}

此時在vm中通過命令列獲取所有key，可以發現 hello01 沒有出現亂碼

127.0.0.1:8888> keys *
1) "\xac\xed\x00\x05t\x00\x05hello"
2) "hello01"

2、low level api

上面的 RedisTemplate 和 StringRedisTemplate 都是封裝好的 Template，可以直接拿來用，屬于 high level api，其實我們還可以使用低階API

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入通用的 RedisTemplate

    @Autowired
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    public void testRedis(){
        /*//設定data
        stringRedisTemplate.opsForValue().set("hello01", "china");
        //獲取data
        System.out.println(stringRedisTemplate.opsForValue().get("hello01"));*/

        //使用低階API，相當于能夠以命令列的方式操作 Redis
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //開發人員手動進行位元組陣列轉換，比較累
        connection.set("hello02".getBytes(),"china".getBytes());
        System.out.println(new String(connection.get("hello02".getBytes())));
    }
}

運行結果：正常設定data

此時在vm中通過命令列獲取所有key，可以發現 hello02 也沒有出現亂碼情況

127.0.0.1:8888> keys *
1) "hello02"
2) "\xac\xed\x00\x05t\x00\x05hello"
3) "hello01"

使用低階的 API，我們可以相當于以命令列的方式操作 Redis，可以進行更細粒度的靈活控制，就是操作有點繁瑣，不如高階 API 用著舒服

3、操作復值——hash

前面我們操作的是 String，在 Redis 中還支持 key-calue 型別的復值，那么對于 hash 這樣的復值應該怎樣操作呢？

1、原始方式存取

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入通用的 RedisTemplate

    @Autowired
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    public void testRedis(){
        //操作復值 hash
        HashOperations<String, Object, Object> hash = stringRedisTemplate.opsForHash();
        hash.put("john", "name", "weijiangming");
        hash.put("john","age", "20");

        System.out.println(hash.entries("john"));
    }
}

運行結果：能夠正常設定和獲取data

此時在vm中通過命令列查看 john 資訊，也能正常獲取和操作

127.0.0.1:8888> hgetall john
1) "name"
2) "weijiangming"
3) "age"
4) "20"
127.0.0.1:8888> hincrby john age 2
(integer) 22

2、封裝成JSON物件存取（Jackson2HashMapper）

原始方式操作物件很麻煩，需要一個屬性一個屬性的往里放，我們更傾向于從外界獲取封裝好的物件，可以直接把物件傳入和取出

1、創建物體物件

Person.class

public class Person {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

既然有這樣的物件，怎樣才能正確的放入 Redis？別人怎樣才能正確的取出來？

官方提供說明：

https://docs.spring.io/spring-data/redis/docs/2.3.4.RELEASE/reference/html/#redis.hashmappers.root

下面我們就以Jackson2HashMapper來演示如何將物件進行映射存盤

首先Jackson2HashMapper需要匯入 pom 支持

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

然后使用Jackson2HashMapper進行物件的存取

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入通用的 RedisTemplate

    @Autowired
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    @Autowired
    ObjectMapper objectMapper;

    public void testRedis(){
        //物件有了，怎么放入 Redis？
        Person p = new Person();
        p.setName("mjt");
        p.setAge(22);

        //創建Jackson2HashMapper物件 jm
        Jackson2HashMapper jm = new Jackson2HashMapper(objectMapper,false);

        //通過 jm，可以完成物件到 hash 的映射
        redisTemplate.opsForHash().putAll("mjt01", jm.toHash(p));

        //取出物件并轉換成map
        Map map = redisTemplate.opsForHash().entries("mjt01");

        Person per = objectMapper.convertValue(map, Person.class);
        System.out.println(per);
    }
}

運行結果：發現能夠以物件地方式正常地存取資料

此時在vm中通過命令列查看 mjt01 資訊：發現 mjt 出現亂碼

127.0.0.1:8888> keys *
1) "\xac\xed\x00\x05t\x00\x05mjt01"

既然使用高階 API 中的 RedisTemplate 會出現亂碼，那我們換一個高階 API StringRedisTemplate

運行結果：出現型別不匹配問題

此時我們發現使用高階 API，要么 JAVA 序列化把 String 破環了，出現亂碼；要么出現型別差異不匹配，序列化會有差異

3、設定序列化器

要解決這個問題，我們條件反射的就會想到設定合適的序列化器就可以了，StringRedisTemplate提供了多種序列化方式，它很靈活

所以在下面的代碼中，我們只比以前多加了一行代碼，其余為改動，就能夠完成 Integer 型別的資料序列化

@Component
public class TestRedis {

    @Autowired
    RedisTemplate redisTemplate;//注入通用的 RedisTemplate

    @Autowired
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    @Autowired
    ObjectMapper objectMapper;

    public void testRedis(){
        //物件有了，怎么放入 Redis？
        Person p = new Person();
        p.setName("mjt02");
        p.setAge(88);

        //未來使用stringRedisTemplate高階api的時候，凡是對hash型別，value都會直接寫成 json 這種格式來完成序列化
        stringRedisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));

        //創建Jackson2HashMapper物件 jm
        Jackson2HashMapper jm = new Jackson2HashMapper(objectMapper,false);

        //通過 jm，可以完成物件到 hash 的映射
        stringRedisTemplate.opsForHash().putAll("mjt02", jm.toHash(p));

        //取出物件并轉換成map
        Map map = stringRedisTemplate.opsForHash().entries("mjt02");

        Person per = objectMapper.convertValue(map, Person.class);
        System.out.println(per);
    }
}

運行結果：正常進行存取，序列化成功

此時在vm中通過命令列查看 mjt02 資訊：能夠正常獲取和操作

127.0.0.1:8888> keys *
1) "mjt02"
127.0.0.1:8888> hgetall mjt02
1) "name"
2) "\"mjt02\""
3) "age"
4) "88"
127.0.0.1:8888> hincrby mjt02 age 2
(integer) 90

4、自定義 Template

上面演示的只是一個方法，里面需要做一堆事情，還需要設定序列化器，如果每一個方法都這樣做是不是有點累？有點扯？如果我們開始的時候，能夠直接拿到一個配置好序列化器的 Template 是不是就很方便？

我們可以自定義一個 Template，創建之初就已經包含了序列化器 Jackson2HashMapper，注入Spring容器之中，拿來即用就行

通過工廠 RedisConnectionFactory 獲得 template，并設定序列化器
MyTemplate.class

@Configuration
public class MyTemplate {

    //把每個方法都需要設定序列化器的步驟抽離出來
    //封裝好，能夠拿來即用
    @Bean
    public StringRedisTemplate ooxx(RedisConnectionFactory fc){
        StringRedisTemplate tp = new StringRedisTemplate(fc);
        //設定序列化器
        tp.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        return tp;
    }
}

此時在原來的代碼中就不必再設定序列化器了

@Component
public class TestRedis {
    
    @Autowired
    @Qualifier("ooxx")
    StringRedisTemplate stringRedisTemplate;//注入操作String的StringRedisTemplate

    @Autowired
    ObjectMapper objectMapper;

    public void testRedis(){
        //物件有了，怎么放入 Redis？
        Person p = new Person();
        p.setName("mjt02");
        p.setAge(88);

        //不必再手動指定序列化器
        //stringRedisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));

        //創建Jackson2HashMapper物件 jm
        Jackson2HashMapper jm = new Jackson2HashMapper(objectMapper,false);

        //通過 jm，可以完成物件到 hash 的映射
        stringRedisTemplate.opsForHash().putAll("mjt02", jm.toHash(p));

        //取出物件并轉換成map
        Map map = stringRedisTemplate.opsForHash().entries("mjt02");

        Person per = objectMapper.convertValue(map, Person.class);
        System.out.println(per);
    }
}

雖然看起來只是簡單的消除了一行代碼，但是再整個專案組中都使用自定義的 Template，我們可以針對不同情況自定義很多個 Template，這樣能夠很大的簡化開發，減少出現問題的概率，代碼更加靈活，更加優雅

三、開發流程總結

使用 Redis 開發流程如下

1. 怎么建立連接
2. 怎么去用：high/low level api，高階/低階 API
3. 資料怎么正確存取：序列化

關聯文章：

Redis入門–萬字長文詳解epoll

Redis——詳解五種資料結構

Redis——Redis的進階使用（管道/發布訂閱/事務/布隆過濾器）

Redis——Redis用作快取（記憶體回收/穿透/擊穿/雪崩）

Redis——Redis用作資料庫（持久化/RDB/AOF）

Redis——Redis集群理論

Redis——集群高可用（腦裂/主從復值/哨兵Sentinel）