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

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

- 以上兩種方式孰優孰劣？字串方式來存取的好處是編碼和除錯更簡單容易，而byte陣列的優勢又在哪裡呢，今天我們針對這兩種儲存方式做一次對比試驗，用資料來得出結論；

### 測試方法簡述
- 本次做的是對比測試，寫Redis和讀Redis都會測試到，測試一共有以下四種：
1. 併發場景下物件透過fastjson轉字串，然後存入Redis；
2. 併發場景下物件透過Kyro序列化成byte陣列，然後存入Redis；
3. 併發場景下從Redis取出字串，透過fastjson轉成物件；
4. 併發場景下從Redis取出byte陣列，然後透過Kyro反序列化成物件；

### 測試環境簡介
- 本次測試需要以下三臺電腦，全部是Linux：
1. Redis伺服器；
2. Web應用伺服器；
3. 安裝有Apache bench，用於發起效能測試，並統計出測試結果；

- 整體部署情況如下：
![這裡寫圖片描述](https://typora-pictures-1253575040.cos.ap-guangzhou.myqcloud.com/70-20220604091422422.png)

### 測試步驟梳理
- 在正式開始前，先將所有步驟整理好以免遺漏，接下來一步一步進行就可以了：
1. 部署Redis；
2. 開發基於字串存取的web應用redis-performance-demo-string；
3. 開發基於Kyro序列化存取的web應用redis-performance-demo-kryo；
4. web應用編譯構建；
5. 在測試端機器上安裝Apache bench；
6. 部署應用redis-performance-demo-string；
7. 用Apache bench先web server發起請求，然後丟棄測試結果，這次請求中部分處理是在JIT之前完成的，不算數；
8. 清理Redis資料，用Apache bench先web server再次發起請求，儲存測試結果；
9. 清理Redis資料，部署應用redis-performance-demo-kryo；
10. 用Apache bench先web server發起請求，然後丟棄測試結果，這次請求中部分處理是在JIT之前完成的，不算數；
11. 清理Redis資料，用Apache bench先web server再次發起請求，儲存測試結果；
12. 對比結果，得出測試結論；

### 本章原始碼下載

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

- 這個git專案中有多個資料夾，本章原始碼在以下兩個資料夾中：
1. **redis-performance-demo-string**：對應字串存取物件的應用；
2. **redis-performance-demo-kryo**：對應kryo序列化物件的應用；

- 如下圖所示：
![這裡寫圖片描述](https://typora-pictures-1253575040.cos.ap-guangzhou.myqcloud.com/70-20220604091422450.png)

### 應用版本
1. JDK：1.8.0_161；
2. Maven：3.5.0；
3. SpringBoot：1.4.1.RELEASE；
4. Redis：3.2.12.；
5. Fastjson：1.2.47；
6. Kryo：4.0.0；
7. Apache bench：2.3；
8. Ubuntu：16.04.3 LTS；

- 接下來我們開始實戰吧；

### 部署Redis
- Redis的安裝和部署就不在本章展開了，以下兩點請注意：
1. 關閉redis遠端保護：**config set protected-mode "no"**；
2. 修改conf檔案，關閉持久化；

### 開發基於字串存取的web應用redis-performance-demo-string
- 這是個基於SpringBoot的簡單web應用，將幾處重點列舉出來：
- 首先是application.properties檔案中有Redis配置資訊，請將IP和埠替換為您的Redis伺服器的IP和埠：
```properties
spring.redis.database=0
spring.redis.host=192.168.31.104
spring.redis.port=6379
spring.redis.pool.maxActive=8    
spring.redis.pool.maxWait=-1    
spring.redis.pool.maxIdle=8    
spring.redis.pool.minIdle=0    
spring.redis.timeout=0 
```

- 其次，是web介面對應的controller類RedisController.java：
```java
@Controller
public class RedisController {

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

private static AtomicInteger addPersionIdGenerator = new AtomicInteger(0);

private static AtomicInteger checkPersionIdGenerator = new AtomicInteger(0);

private static final String PREFIX = "person_";

private static final int TIMES = 100;

@Autowired
    private StringRedisTemplate stringRedisTemplate;

@RequestMapping(value = "/save/{key}/{value}", method = RequestMethod.GET)
    @ResponseBody
    public String save(@PathVariable("key") final String key, @PathVariable("value") final String value) {
        try{
            stringRedisTemplate.opsForValue().set(key, value);
        }catch(Exception e){
            e.printStackTrace();
        }
        return "1. success";
    }

@RequestMapping(value = "/checksingle/{id}", method = RequestMethod.GET)
    public void check(@PathVariable("id") final int id, HttpServletResponse response) {
        checkPerson(id, response);
    }

@RequestMapping(value = "/check", method = RequestMethod.GET)
 public void check(HttpServletResponse response) {
 boolean hasError = false;
 for(int i=0;i<times boolean="" rlt="checkPerson(checkPersionIdGenerator.incrementAndGet()," response="" if="" haserror="true;" break="" helper.success="" success="" method="RequestMethod.GET)" public="" void="" add="" issuccess="" for="" i="0;i<TIMES;i++)" person="" while="" try="" stringredistemplate.opsforvalue="" person.getid="" jsonobject.tojsonstring="" catch="" e="" logger.error="" redis="" error="" return="" else="" thread.sleep="" sleep="" reset="" addpersionidgenerator.set="" checkpersionidgenerator.set="" generator="" id="" private="" checkperson="" httpservletresponse="" string="" raw="null;" from="" helper.error="" not="" exist="" false="" person.class="" check="" true="" bench="" springboot="" class="" rediscontroller="" static="" final="" logger="" atomicinteger="" addpersionidgenerator="new" checkpersionidgenerator="new" prefix="person_" int="" times="100;" redisclient="" redisclient.set="" object="" :="" web="" clean="" package="" redis-performance-demo-string-0.0.1-snapshot.jar="" apt-get="" install="" apache2-utils="">redis-performance-demo-string-0.0.1-SNAPSHOT.jar**，即可啟動應用；

### redis-performance-demo-string應用預熱
- 用Apache bench先web server發起請求，然後丟棄測試結果，因為這次請求中部分處理是在JIT之前完成的，不算數；
- 在Apache bench所在機器上執行如下命令即可發起序列化和寫入Redis的效能測試：
```shell
ab -n 5000 -c 200 http://192.168.31.104:8080/add
```
- 以上是序列化和寫入Redis的測試，執行完畢後再執行下面的讀Redis和反序列化的效能測試：
```shell
ab -n 5000 -c 200 http://192.168.31.104:8080/check
```
**192.168.31.104**是部署redis-performance-demo-string應用的應用伺服器IP地址，8080是應用啟動後監聽的埠；

### 正式壓測redis-performance-demo-string並儲存結果
- 先清理預熱時殘留的資料，在Redis伺服器上執行**redis-cli**進入命令列，然後執行**flushall**清除該Redis所有資料，注意：**該命令會刪除Redis上全部資料，請慎用！！！**；
- 透過瀏覽器訪問地址：http://192.168.31.104:8080/reset， 將生成id的全域性變數重新設定為0；
- **測試序列化和寫入**，在Apache bench所在機器再次執行**ab -n 150000 -c 200 http://192.168.31.104:8080/add** ， 等測試結束後，記錄測試結果中的三個關鍵資訊如下：

| 名稱 | 數值 | 含義 |
| :--------------------------------------------------------- | :------ | :----------------------------------------------------------- |
| Requests per second | 399.18 | 每秒吞吐率，單位時間內能處理的最大請求數 |
| Time per request | 501.033 | 使用者平均請求等待時間，毫秒 |
| Time per request (mean, across all concurrent requests) | 2.505 | 伺服器平均請求等待時間； 它是吞吐率的倒數； 它也等於"使用者平均請求等待時間"除以"併發使用者數" |

- 去Redis伺服器執行命令**info**，得到Redis記憶體使用大小為3.30G(used_memory_human)；
- 去Redis伺服器執行命令**dbsize**，得到記錄數為15000000，符合預期；
- **測試反序列化和讀取**，在Apache bench所在機器執行**ab -n 150000 -c 200 http://192.168.31.104:8080/check** ，等測試結束後，記錄測試結果中的三個關鍵資訊如下：

| 名稱 | 數值 | 含義 |
| :--------------------------------------------------------- | :------ | :----------------------------------------------------------- |
| Requests per second | 425.22 | 每秒吞吐率，單位時間內能處理的最大請求數 |
| Time per request | 470.341 | 使用者平均請求等待時間，毫秒 |
| Time per request (mean, across all concurrent requests) | 2.352 | 伺服器平均請求等待時間； 它是吞吐率的倒數； 它也等於"使用者平均請求等待時間"除以"併發使用者數" |

### 部署應用redis-performance-demo-kryo
- 將前面生成的redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar檔案複製到web應用伺服器上，執行命令**java -jar >redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar**，即可啟動應用；

### redis-performance-demo-kryo應用預熱
- 用Apache bench先web server發起請求，然後丟棄測試結果，因為這次請求中部分處理是在JIT之前完成的，不算數；
- 在Apache bench所在機器上執行如下命令即可發起序列化和寫入Redis的效能測試：
```shell
ab -n 5000 -c 200 http://192.168.31.104:18080/add
```
- 以上是序列化和寫入Redis的測試，執行完畢後再執行下面的讀Redis和反序列化的效能測試：
```shell
ab -n 5000 -c 200 http://192.168.31.104:18080/check
```
**192.168.31.104**是部署redis-performance-demo-kryo應用的應用伺服器IP地址，18080是應用啟動後監聽的埠；

### 正式壓測redis-performance-demo-kryo並儲存結果
- 先清理預熱時殘留的資料，在Redis伺服器上執行**redis-cli**進入命令列，然後執行**flushall**清除該Redis所有資料，注意：**該命令會刪除Redis上全部資料，請慎用！！！**；
- 透過瀏覽器訪問地址：http://192.168.31.104:18080/reset， 將生成id的全域性變數重新設定為0；
- **測試序列化和寫入**，在Apache bench所在機器再次執行**ab -n 150000 -c 200 http://192.168.31.104:18080/add** ， 等測試結束後，記錄測試結果中的三個關鍵資訊如下：

| 名稱 | 數值 | 含義 |
| :--------------------------------------------------------- | :------ | :----------------------------------------------------------- |
| Requests per second | 381.06 | 每秒吞吐率，單位時間內能處理的最大請求數 |
| Time per request | 524.851 | 使用者平均請求等待時間，毫秒 |
| Time per request (mean, across all concurrent requests) | 2.624 | 伺服器平均請求等待時間； 它是吞吐率的倒數； 它也等於"使用者平均請求等待時間"除以"併發使用者數" |

- 去Redis伺服器執行命令**info**，得到Redis記憶體使用大小為3.20G：
- 去Redis伺服器執行命令**dbsize**，得到記錄數為15000000，符合預期；
- **測試反序列化和讀取**，在Apache bench所在機器執行**ab -n 50000 -c 500 http://192.168.31.104:18080/check** ，等測試結束後，記錄測試結果中的三個關鍵資訊如下：

| 名稱 | 數值 | 含義 |
| :--------------------------------------------------------- | :------ | :----------------------------------------------------------- |
| Requests per second | 386.49 | 每秒吞吐率，單位時間內能處理的最大請求數 |
| Time per request | 517.484 | 使用者平均請求等待時間，毫秒 |
| Time per request (mean, across all concurrent requests) | 2.587 | 伺服器平均請求等待時間； 它是吞吐率的倒數； 它也等於"使用者平均請求等待時間"除以"併發使用者數" |

- 至此，效能測試已經完畢，我們把關鍵的QPS和記憶體大小拿來對比一下，如下表所示：

| 名稱                              | string | Kryo   |
| :-------------------------------- | :----- | :----- |
| 每秒吞吐率（序列化和寫入Reids）   | 399.18 | 381.06 |
| 每秒吞吐率（反序列化和讀取Reids） | 425.22 | 386.49 |
| 所佔記憶體大小                      | 3.30G  | 3.20G  |

- 從以上對比可以發現：
1. 兩種序列化方案的資料存入Redis後，kryo佔用記憶體小於string，但是優勢並不明顯；
2. 不論是讀還是寫，kryo方案的吞吐率低於sting方案，這和之前預期的不同，但是網上已經有很多實踐證明kryo方案的速度優於字串方案，所以除了kryo本身的優勢，對於kryo方案的整合以及redis連線管理等因素對吞吐率都有影響，SpringBoot的StringRedisTemplate看來是個優秀的處理工具；

- 測試的硬體環境與生產環境有著不小差別，所以資料僅供參考，也可能是我的測試程式碼質量堪憂所致（囧），如果您發現其中的問題，期待您的及時指正；

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

實戰Redis序列化效能測試(Kryo和字串)

相關文章