Redis 是⽬前使⽤最⼴泛的緩存中間件，相⽐ Memcached，Redis ⽀持更多的數據結構和更豐富的數據操
作，另外 Redis 有着豐富的集羣⽅案和使⽤場景，這⼀課我們⼀起學習 Redis 的常⽤操作。
Redis 介紹
Redis 是⼀個速度⾮常快的⾮關係數據庫（Non-Relational Database），它可以存儲鍵（Key）與 5 種不同
類型的值（Value）之間的映射（Mapping），可以將存儲在內存的鍵值對數據持久化到硬盤，可以使⽤複製
特性來擴展讀性能，還可以使⽤客戶端分⽚來擴展寫性能。
爲了滿⾜⾼性能，Redis 採⽤內存（in-memory）數據集（Dataset），根據使⽤場景，可以通過每隔⼀段時
間轉儲數據集到磁盤，或者追加每條命令到⽇志來持久化。持久化也可以被禁⽤，如果你只是需要⼀個功能
豐富、⽹絡化的內存緩存。
數據模型
Redis 數據模型不僅與關係數據庫管理系統（RDBMS）不同，也不同於任何簡單的 NoSQL 鍵-值數據存儲。
Redis 數據類型類似於編程語⾔的基礎數據類型，因此開發⼈員感覺很⾃然，每個數據類型都⽀持適⽤於其
類型的操作，受⽀持的數據類型包括：
- string（字符串）
- hash（哈希）
- list（列表）
- set（集合）
- zset（sorted set：有序集合）
關鍵優勢
Redis 的優勢包括它的速度、對富數據類型的⽀持、操作的原⼦性，以及通⽤性：
- 性能極⾼，它每秒可執⾏約 100,000 個 SET 以及約 100,000 個 GET 操作；
- 豐富的數據類型，Redis 對⼤多數開發⼈員已知的⼤多數數據類型提供了原⽣⽀持，這使得各種問題得 以輕鬆解決；
- 原⼦性，因爲所有 Redis 操作都是原⼦性的，所以多個客戶端會併發地訪問⼀個 Redis 服務器，獲取相 同的更新值；
- 豐富的特性，Redis 是⼀個多效⽤⼯具，有⾮常多的應⽤場景，包括緩存、消息隊列（Redis 原⽣⽀持 發佈/訂閱）、短期應⽤程序數據（⽐如 Web 會話、Web ⻚⾯命中計數）等。
spring-boot-starter-data-redis
Spring Boot 提供了對 Redis 集成的組件包：spring-boot-starter-data-redis，它依賴於 spring-data-redis 和
lettuce。Spring Boot 1.0 默認使⽤的是 Jedis 客戶端，2.0 替換成了 Lettuce，但如果你從 Spring Boot 1.5.X
切換過來，⼏乎感受不⼤差異，這是因爲 spring-boot-starter-data-redis 爲我們隔離了其中的差異性。
- Lettuce：是⼀個可伸縮線程安全的 Redis 客戶端，多個線程可以共享同⼀個 RedisConnection，它利⽤ 優秀 Netty NIO 框架來⾼效地管理多個連接。
- Spring Data：是 Spring 框架中的⼀個主要項⽬，⽬的是爲了簡化構建基於 Spring 框架應⽤的數據訪 問，包括⾮關係數據庫、Map-Reduce 框架、雲數據服務等，另外也包含對關係數據庫的訪問⽀持。
- Spring Data Redis：是 Spring Data 項⽬中的⼀個主要模塊，實現了對 Redis 客戶端 API 的⾼度封裝， 使對 Redis 的操作更加便捷。
可以⽤以下⽅式來表達它們之間的關係：
Lettuce ! Spring Data Redis ! Spring Data ! spring-boot-starter-data-redis
因此 Spring Data Redis 和 Lettuce 具備的功能，spring-boot-starter-data-redis ⼏乎都會有。
快速上⼿
相關配置
引⼊依賴包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
引⼊ commons-pool 2 是因爲 Lettuce 需要使⽤ commons-pool 2 創建 Redis 連接池。
application 配置GitChat
# Redis 數據庫索引（默認爲 0）
spring.redis.database=0
# Redis 服務器地址
spring.redis.host=localhost
# Redis 服務器連接端⼝
spring.redis.port=6379
# Redis 服務器連接密碼（默認爲空）
spring.redis.password=
# 連接池最⼤連接數（使⽤負值表示沒有限制） 默認 8
spring.redis.lettuce.pool.max-active=8
# 連接池最⼤阻塞等待時間（使⽤負值表示沒有限制） 默認 -1
spring.redis.lettuce.pool.max-wait=-1
# 連接池中的最⼤空閒連接 默認 8
spring.redis.lettuce.pool.max-idle=8
# 連接池中的最⼩空閒連接 默認 0
spring.redis.lettuce.pool.min-idle=0
從配置也可以看出 Spring Boot 默認⽀持 Lettuce 連接池。
緩存配置
在這⾥可以爲 Redis 設置⼀些全局配置，⽐如配置主鍵的⽣產策略 KeyGenerator，如不配置會默認使⽤參數
名作爲主鍵。
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
@Bean
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params)
{
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
}
注意，我們使⽤了註解：@EnableCaching 來開啓緩存。GitChat
測試使⽤
在單元測試中，注⼊ RedisTemplate。String 是最常⽤的⼀種數據類型，普通的 key/value 存儲都可以歸爲此
類，value 其實不僅是 String 也可以是數字。
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestRedisTemplate {
@Autowired
private RedisTemplate redisTemplate;
@Test
public void testString() {
redisTemplate.opsForValue().set("neo", "ityouknow");
Assert.assertEquals("ityouknow", redisTemplate.opsForValue().get("neo"));
}
}
在這個單元測試中，我們使⽤ redisTemplate 存儲了⼀個字符串 "ityouknow"，存儲之後獲取進⾏驗證，多次
進⾏ set 相同的 key，鍵對應的值會被覆蓋。
從上⾯的整個流程來看，使⽤ spring-boot-starter-data-redis 只需要三步就可以快速地集成 Redis 進⾏操作，
下⾯介紹 Redis 如何操作各種數據類型。
各類型實踐
我們知道 Redis ⽀持多種數據類型，實體、哈希、列表、集合、有序集合，那麼在 Spring Boot 體系中都如
何使⽤呢？
實體
先來看 Redis 對 Pojo 的⽀持，新建⼀個 User 對象，放到緩存中，再取出來。
@Test
public void testObj(){
User user=new User("[email protected]", "smile", "youknow", "know","2020");
ValueOperations<String, User> operations=redisTemplate.opsForValue();
operations.set("com.neo", user);
User u=operations.get("com.neo");
System.out.println("user: "+u.toString());
}
輸出結果：
user: com.neo.domain.User@16fb356[id=<null>,userName=know,passWord=youknow,email=i
[email protected],nickName=smile,regTime=2020]
驗證發現完美⽀持對象的存⼊和讀取。
超時失效
Redis 在存⼊每⼀個數據的時候都可以設置⼀個超時時間，過了這個時間就會⾃動刪除數據，這種特性⾮常
適合我們對階段數據的緩存。
新建⼀個 User 對象，存⼊ Redis 的同時設置 100 毫秒後失效，設置⼀個線程暫停 1000 毫秒之後，判斷數
據是否存在並打印結果。
@Test
public void testExpire() throws InterruptedException {
User user=new User("[email protected]", "expire", "youknow", "expire","2020");
ValueOperations<String, User> operations=redisTemplate.opsForValue();
operations.set("expire", user,100,TimeUnit.MILLISECONDS);
Thread.sleep(1000);
boolean exists=redisTemplate.hasKey("expire");
if(exists){
System.out.println("exists is true");
}else{
System.out.println("exists is false");
}
}
輸出結果：
exists is false
從結果可以看出，Reids 中已經不存在 User 對象了，此數據已經過期，同時我們在這個測試的⽅法中使⽤了
hasKey("expire") ⽅法，可以判斷 key 是否存在。
刪除數據
有些時候，我們需要對過期的緩存進⾏刪除，下⾯來測試此場景的使⽤。⾸ set ⼀個字符串“ityouknow”，緊
接着刪除此 key 的值，再進⾏判斷。GitChat
@Test
public void testDelete() {
ValueOperations<String, User> operations=redisTemplate.opsForValue();
redisTemplate.opsForValue().set("deletekey", "ityouknow");
redisTemplate.delete("deletekey");
boolean exists=redisTemplate.hasKey("deletekey");
if(exists){
System.out.println("exists is true");
}else{
System.out.println("exists is false");
}
}
輸出結果：
exists is false
結果表明字符串“ityouknow”已經被成功刪除。
Hash（哈希）
⼀般我們存儲⼀個鍵，很⾃然的就會使⽤ get/set 去存儲，實際上這並不是很好的做法。Redis 存儲⼀個 key
會有⼀個最⼩內存，不管你存的這個鍵多⼩，都不會低於這個內存，因此合理的使⽤ Hash 可以幫我們節省
很多內存。
Hash Set 就在哈希表 Key 中的域（Field）的值設爲 value。如果 Key 不存在，⼀個新的哈希表被創建並進
⾏ HSET 操作；如果域（fifield）已經存在於哈希表中，舊值將被覆蓋。
@Test
public void testHash() {
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
hash.put("hash","you","you");
String value=(String) hash.get("hash","you");
System.out.println("hash value :"+value);
}
輸出結果：
hash value :you
根據上⾯測試⽤例發現，Hash set 的時候需要傳⼊三個參數，第⼀個爲 key，第⼆個爲 fifield，第三個爲存儲
的值。⼀般情況下 Key 代表⼀組數據，fifield 爲 key 相關的屬性，⽽ value 就是屬性對應的值。
List
Redis List 的應⽤場景⾮常多，也是 Redis 最重要的數據結構之⼀。 使⽤ List 可以輕鬆的實現⼀個隊列，
List 典型的應⽤場景就是消息隊列，可以利⽤ List 的 Push 操作，將任務存在 List 中，然後⼯作線程再⽤
POP 操作將任務取出進⾏執⾏。
@Test
public void testList() {
ListOperations<String, String> list = redisTemplate.opsForList();
list.leftPush("list","it");
list.leftPush("list","you");
list.leftPush("list","know");
String value=(String)list.leftPop("list");
System.out.println("list value :"+value.toString());
}
輸出結果：
list value :know
上⾯的例⼦我們從左側插⼊⼀個 key 爲 "list" 的隊列，然後取出左側最近的⼀條數據。其實 List 有很多 API
可以操作，⽐如從右側進⾏插⼊隊列從右側進⾏讀取，或者通過⽅法 range 讀取隊列的⼀部分。接着上⾯的
例⼦我們使⽤ range 來讀取。
List<String> values=list.range("list",0,2);
for (String v:values){
System.out.println("list range :"+v);
}
輸出結果：
list range :know
list range :you
list range :it
range 後⾯的兩個參數就是插⼊數據的位置，輸⼊不同的參數就可以取出隊列中對應的數據。
Redis List 的實現爲⼀個雙向鏈表，即可以⽀持反向查找和遍歷，更⽅便操作，不過帶來了部分額外的
內存開銷，Redis 內部的很多實現，包括髮送緩衝隊列等也都是⽤的這個數據結構。
Set
Redis Set 對外提供的功能與 List 類似是⼀個列表的功能，特殊之處在於 Set 是可以⾃動排重的，當你需要
存儲⼀個列表數據，⼜不希望出現重複數據時，Set 是⼀個很好的選擇，並且 Set 提供了判斷某個成員是否
在⼀個 Set 集合內的重要接⼝，這個也是 List 所不能提供的。
@Test
public void testSet() {
String key="set";
SetOperations<String, String> set = redisTemplate.opsForSet();
set.add(key,"it");
set.add(key,"you");
set.add(key,"you");
set.add(key,"know");
Set<String> values=set.members(key);
for (String v:values){
System.out.println("set value :"+v);
}
}
輸出結果：
set value :it
set value :know
set value :you
通過上⾯的例⼦我們發現，輸⼊了兩個相同的值“you”，全部讀取的時候只剩下了⼀條，說明 Set 對隊列進⾏
了⾃動的排重操作。
Redis 爲集合提供了求交集、並集、差集等操作，可以⾮常⽅便的使⽤。
測試 difference
SetOperations<String, String> set = redisTemplate.opsForSet();
String key1="setMore1";
String key2="setMore2";
set.add(key1,"it");
set.add(key1,"you");
set.add(key1,"you");
set.add(key1,"know");
set.add(key2,"xx");
set.add(key2,"know");
Set<String> diffs=set.difference(key1,key2);
for (String v:diffs){
System.out.println("diffs set value :"+v);
}
輸出結果:
diffs set value :it
diffs set value :you
根據上⾯這個例⼦可以看出，difference() 函數會把 key 1 中不同於 key 2 的數據對⽐出來，這個特性適合我
們在⾦融場景中對賬的時候使⽤。
測試 unions
SetOperations<String, String> set = redisTemplate.opsForSet();
String key3="setMore3";
String key4="setMore4";
set.add(key3,"it");
set.add(key3,"you");
set.add(key3,"xx");
set.add(key4,"aa");
set.add(key4,"bb");
set.add(key4,"know");
Set<String> unions=set.union(key3,key4);
for (String v:unions){
System.out.println("unions value :"+v);
}
輸出結果：
unions value :know
unions value :you
unions value :xx
unions value :it
unions value :bb
unions value :aa
根據例⼦我們發現，unions 會取兩個集合的合集，Set 還有其他很多類似的操作，⾮常⽅便我們對集合進⾏
數據處理。
Set 的內部實現是⼀個 Value 永遠爲 null 的 HashMap，實際就是通過計算 Hash 的⽅式來快速排重，
這也是 Set 能提供判斷⼀個成員是否在集合內的原因。
ZSet
Redis Sorted Set 的使⽤場景與 Set 類似，區別是 Set 不是⾃動有序的，⽽ Sorted Set 可以通過⽤戶額外提
供⼀個優先級（Score）的參數來爲成員排序，並且是插⼊有序，即⾃動排序。
在使⽤ Zset 的時候需要額外的輸⼊⼀個參數 Score，Zset 會⾃動根據 Score 的值對集合進⾏排序，我們可
以利⽤這個特性來做具有權重的隊列，⽐如普通消息的 Score 爲1，重要消息的 Score 爲 2，然後⼯作線程
可以選擇按 Score 的倒序來獲取⼯作任務。GitChat
@Test
public void testZset(){
String key="zset";
redisTemplate.delete(key);
ZSetOperations<String, String> zset = redisTemplate.opsForZSet();
zset.add(key,"it",1);
zset.add(key,"you",6);
zset.add(key,"know",4);
zset.add(key,"neo",3);
Set<String> zsets=zset.range(key,0,3);
for (String v:zsets){
System.out.println("zset value :"+v);
}
Set<String> zsetB=zset.rangeByScore(key,0,3);
for (String v:zsetB){
System.out.println("zsetB value :"+v);
}
}
輸出結果：
zset value :it
zset value :neo
zset value :know
zset value :you
zsetB value :it
zsetB value :neo
通過上⾯的例⼦我們發現插⼊到 Zset 的數據會⾃動根據 Score 進⾏排序，根據這個特性我們可以做優先隊
列等各種常⻅的場景。另外 Redis 還提供了 rangeByScore 這樣的⼀個⽅法，可以只獲取 Score 範圍內排序
後的數據。
Redis Sorted Set 的內部使⽤ HashMap 和跳躍表（SkipList）來保證數據的存儲和有序，HashMap ⾥
放的是成員到 Score 的映射，⽽跳躍表⾥存放的是所有的成員，排序依據是 HashMap ⾥存的 Score，
使⽤跳躍表的結構可以獲得⽐較⾼的查找效率，並且在實現上⽐較簡單。
封裝
在我們實際的使⽤過程中，不會給每⼀個使⽤的類都注⼊ redisTemplate 來直接使⽤，⼀般都會對業務進⾏
簡單的包裝，最後提供出來對外使⽤。
我們舉兩個例⼦說明。
⾸先定義⼀個 RedisService 服務，將 RedisTemplate 注⼊到類中。
@Service
public class RedisService {
@Autowired
private RedisTemplate redisTemplate;
}
封裝簡單插⼊操作：
public boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForVal
ue();
operations.set(key, value);
result = true;
} catch (Exception e) {
logger.error("set error: key {}, value {}",key,value,e);
}
return result;
}
會對其中出現的異常繼續處理，反饋給調⽤⽅。
⽐如我們想刪除某⼀類的 Key 的值。
public void removePattern(final String pattern) {
Set<Serializable> keys = redisTemplate.keys(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
}
使⽤ Redis 的 Pattern 來匹配出⼀批符合條件的緩存，然後批量進⾏刪除。
還有其他封裝⽅法，⽐如刪除的時候先判斷 Key 是否存在等，這些簡單的業務判斷都應該封裝在
RedisService，對外提供最簡單的 API 調⽤即可。
@Autowired
private RedisService redisService;
@Test
public void testString() throws Exception {
redisService.set("neo", "ityouknow");
Assert.assertEquals("ityouknow", redisService.get("neo"));
}
在其他服務使⽤的時候將 RedisService 注⼊其中，調⽤對應的⽅法來操作 Redis，這樣會更優雅簡單⼀些。GitChat
總結
Redis 是⼀款⾮常優秀的⾼性能緩存中間件，被⼴泛的使⽤在各互聯⽹公司中，Spring Boot 對 Redis 的操作
提供了很多⽀持，可以⾮常⽅便的去集成。Redis 擁有豐富的數據類型，⽅便我們在不同的業務場景中去使
⽤，特別是提供了很多內置的⾼效集合操作，在業務中使⽤⾮常⽅便。
