### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

### 本篇概覽
- 有時候我們需要將Java物件例項存入Redis，常用方法有兩種：
1. 將物件序列化成字串後存入Redis；
2. 將物件序列化成byte陣列後存入Redis；

本章實戰上述第二種方式，並且序列化工具選擇了Kyro，為了便於開發和驗證，將程式碼寫在一個基於SpringBoot的web工程中；

### 原始碼下載
- 本章實戰的原始碼可以在github下載，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，本章原始碼在**springboot-redis-kyro-demo**資料夾下，如下圖所示：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220603/1654217669187792052.png)

### 環境資訊
1. JDK：1.8.0_144；
1. SpringBoot：1.4.1.RELEASE；
1. Kyro：4.0.0；
1. Redis：3.2.11；

### 開發步驟列表
- 動手前先將整體步驟梳理一下：
1. 準備Reids環境；
2. 建立SpringBoot工程，新增依賴；
3. 在application.properties中配置Redis相關資訊；
4. 建立基於Kyro的序列化介面實現類；
5. 建立Redis配置類；
6. 將存、取、刪除等針對物件的基本操作封裝成一個服務類；
7. 開發一個Controller，對應幾個web介面，用來驗證對Redis的存、取、刪除操作；
8. 啟動工程，透過web請求操作，並在Redis後臺檢查資料；

- 步驟已經列清楚了，開始實戰吧！

### 準備Redis環境
- 如何安裝Reids就不在本章展開了，請自行準備，我這裡為了省事是在Docker上裝的，只需以下一行命令即可（前提是Docker可用）：
```shell
docker run --name redis -p 6379:6379 -idt redis:3.2.11 redis-server --appendonly yes
```

### 建立SpringBoot工程，新增依賴
- spring-boot-starter-parent的版本是1.4.1.RELEASE；
- 基於maven建立SpringBoot工程，需要依賴：spring-boot-starter-web、spring-boot-starter-data-redis；
- 在pom.xml檔案中新增kyro、fastjson依賴，如下：
```xml

        <dependency>
            <groupid>com.esotericsoftware</groupid>
            <artifactid>kryo</artifactid>
            <version>4.0.0</version>
        </dependency>

<dependency>
            <groupid>de.javakaffee</groupid>
            <artifactid>kryo-serializers</artifactid>
            <version>0.41</version>
        </dependency>

<dependency>
            <groupid>com.alibaba</groupid>
            <artifactid>fastjson</artifactid>
            <version>1.2.47</version>
        </dependency>
```

### 在application.properties中配置Redis相關資訊
application.properties中的配置資訊如下，請注意IP地址和埠：
```properties
spring.redis.database=0
spring.redis.host=192.168.31.104
spring.redis.port=6379
spring.redis.pool.max-active=2500
spring.redis.pool.max-wait=6000
spring.redis.pool.max-idle=500
spring.redis.pool.min-idle=100
spring.redis.pool.testOnBorrow=true
spring.redis.pool.blockWhenExhausted=true
spring.redis.pool.numTestsPerEvictionRun=3
spring.redis.pool.timeBetweenEvictionRunsMillis=-1
spring.redis.timeout=1000
```

### 建立基於Kyro的序列化介面實現類
- 建立RedisSerializer介面的實現類，後續的序列化和反序列化操作都由該類完成：
```java
public class KryoRedisSerializer<t> implements RedisSerializer<t> {
    private static final Logger logger = LoggerFactory.getLogger(KryoRedisSerializer.class);

public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

private static final ThreadLocal<kryo> kryos = ThreadLocal.withInitial(Kryo::new);

private Class<t> clazz;

public KryoRedisSerializer(Class<t> clazz) {
        super();
        this.clazz = clazz;
    }

@Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return EMPTY_BYTE_ARRAY;
        }

Kryo kryo = kryos.get();
        kryo.setReferences(false);
        kryo.register(clazz);

try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             Output output = new Output(baos)) {
            kryo.writeClassAndObject(output, t);
            output.flush();
            return baos.toByteArray();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

return EMPTY_BYTE_ARRAY;
    }

@Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }

Kryo kryo = kryos.get();
        kryo.setReferences(false);
        kryo.register(clazz);

try (Input input = new Input(bytes)) {
            return (T) kryo.readClassAndObject(input);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

return null;
    }
}
```
- 上述程式碼有以下三點需要注意：
1. kryos是ThreadLocal物件，由ThreadLocal.withInitial建立，如此一來，每次呼叫kryos.get方法，都能取出當前執行緒對應的Kryo例項，如果沒有會呼叫new方法建立；
2. serialize方法負責將物件例項序列化成byte陣列；
3. deserialize方法複製將byte陣列反序列化成物件例項；

### 建立Redis配置類
- Redis配置類如下，透過setValueSerializer方法將KryoRedisSerializer設定位value的序列化器：
```java
@Configuration
public class RedisConfig {

/**
     * redisTemplate 序列化使用的Serializeable, 儲存二進位制位元組碼, 所以自定義序列化類
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<object object=""> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<object object=""> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

// redis value使用的序列化器
        template.setValueSerializer(new KryoRedisSerializer<>(Object.class));
        // redis key使用的序列化器
        template.setKeySerializer(new StringRedisSerializer());

template.afterPropertiesSet();
        return template;
    }
}
```

### 將存、取、刪除等針對物件的基本操作封裝成一個服務類
- 本次會用到存、取、刪除等操作，所以做個簡單的封裝，實際使用中，您可以自己定製：
```java
/**
 * @Description : 封裝了redis的操作
 * @Author : zq2599@gmail.com
 * @Date : 2018-06-10 22:52
 */
@Service
public class RedisClient {

private static final Logger logger = LoggerFactory.getLogger(RedisClient.class);

@Autowired
    private RedisTemplate<object object=""> redisTemplate;

private RedisConnection getConnection() {
        return redisTemplate.getConnectionFactory().getConnection();
    }

/**
     * 釋放連線
     * @param redisConnection
     */
    private void releaseConnection(RedisConnection redisConnection){
        if(null!=redisConnection && null!=redisTemplate){
            RedisConnectionFactory redisConnectionFactory = redisTemplate.getConnectionFactory();

if(null!=redisConnectionFactory){
                RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
            }
        }
    }

/**
     * 獲取快取的key
     * @param id
     * @return
     */
    private <t> byte[] getKey(T id) {
        RedisSerializer serializer = redisTemplate.getKeySerializer();
        return serializer.serialize(id);
    }

/**
     * 更新快取中的物件，也可以在redis快取中存入新的物件
     *
     * @param key
     * @param t
     * @param <t>
     */
    public <t> void set(String key, T t) {
        byte[] keyBytes = getKey(key);
        RedisSerializer serializer = redisTemplate.getValueSerializer();
        byte[] val = serializer.serialize(t);
        RedisConnection redisConnection = getConnection();

if(null!=redisConnection){
            try {
                redisConnection.set(keyBytes, val);
            }finally {
                releaseConnection(redisConnection);
            }
        }else{
            logger.error("1. can not get valid connection");
        }
    }

/**
     * 刪除指定物件
     * @param key
     * @return
     */
    public long del(String key){
        RedisConnection redisConnection = getConnection();
        long rlt = 0L;

if(null!=redisConnection){
            try {
                rlt = redisConnection.del(getKey(key));
            }finally {
                releaseConnection(redisConnection);
            }
        }else{
            logger.error("1. can not get valid connection");
        }
        return rlt;
    }

/**
     * 從快取中取物件
     *
     * @param key
     * @param <t>
     * @return
     */
    public <t> T getObject(String key) {
        byte[] keyBytes = getKey(key);
        byte[] result = null;

RedisConnection redisConnection = getConnection();

if(null!=redisConnection){
            try {
                result = redisConnection.get(keyBytes);
            }finally {
                releaseConnection(redisConnection);
            }
        }else{
            logger.error("2. can not get valid connection");
        }

return null!=redisConnection ? (T) redisTemplate.getValueSerializer().deserialize(result) : null;
    }
}
```
- 以上程式碼有一處需注意：**Redis連線物件RedisConnection使用完畢後，一定要記得釋放！**
- 上面用到的Person是個簡單物件，如下：
```java
package com.bolingcavalry.springbootrediskyrodemo.bean;

import java.io.Serializable;

public class Person implements Serializable{

private static final long serialVersionUID = 1L;

private int id;

private String name;

private int age;

public String getName() {
        return name;
    }

public int getId() {
        return id;
    }

public void setId(int id) {
        this.id = id;
    }

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

public int getAge() {
        return age;
    }

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

### 啟動工程，透過web請求操作，並在Redis後臺檢查資料
- 現在可以啟動SpringBoot工程進行驗證了：
1. 執行SpringBootApplication；
2. 在瀏覽器輸入http://localhost:8080/add/1/Jerry/11即可新增一條記錄（注意localhost:8080換成您的服務所在地址和埠），如下圖：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220603/1654217697264545666.png)

3. 用redis-cli命令登入redis，執行命令**get person_1**，看到內容如下：
```shell
root@00afb3eb191b:/data# redis-cli
127.0.0.1:6379> get person_1
"\x01\x00com.bolingcavalry.springbootrediskyrodemo.bean.Perso\xee\x02\x02Jerr\xf9"
```

4. 在瀏覽器輸入http://localhost:8080/get/1即可查詢記錄，如下圖：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220603/1654217707214938111.png)

5. 在瀏覽器輸入http://localhost:8080/del/1即可刪除記錄，如下圖：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220603/1654217714213846916.png)

6. 在瀏覽器輸入http://localhost:8080/get/1查詢記錄，會提示找不到記錄，如下圖：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220603/1654217722878663094.png)

7. Redis後臺也查不到了：
```shell
127.0.0.1:6379> get person_1
(nil)
```

- 至此，使用Kyro作為redis序列化工具的實戰已經完成，希望能對您的開發提供一些參考；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</t></t></t></t></t></object></object></object></t></t></kryo></t></t>

SpringBoot下用Kyro作為Redis序列化工具

相關文章