最近在學習Spring Boot 2.x整合Redis，在這里和大家分享一下，希望對大家有幫助。
Redis是什么
Redis 是開源免費高性能的key-value數據庫。有以下的優勢（源於Redis官網http://www.redis.net.cn/）：
-
性能極高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s 。
-
豐富的數據類型 – Redis支持二進制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 數據類型操作。
-
原子 – Redis的所有操作都是原子性的，意思就是要么成功執行要么失敗完全不執行。單個操作是原子性的。多個操作也支持事務，即原子性，通過MULTI和EXEC指令包起來。
-
豐富的特性 – Redis還支持 publish/subscribe, 通知, key 過期等等特性。
如果想了解更多關於Redis是什么，可以參考：Redis初識
為什么要使用Redis
為什么要使用Redis？21世紀以來信息技術的飛速發展，我們已經迎來了大數據時代，數據較之前爆炸增長，並發訪問量激增；由之帶來的就是系統設計由單體架構向分布式架構的轉變和演進。對於緩存這個問題，如果系統是單體的系統，可以在單個的JVM里面進行本地緩存，例如可以用HashMap來緩存一些數據。但是到了分布式系統里面，一個大系統里面有很多個子系統，那他們之間如何共享緩存？這就需要Redis，用Redis來實現緩存系統。都說“時勢造英雄”，其實我想說Redis的大規模使用也是這個道理，用Redis做緩存系統從性能和並發兩方面考慮都是值得肯定的。
- 性能：如果碰到需要執行耗時特別久，且結果不頻繁變動的SQL，就特別適合將運行結果放入緩存。這樣，后面的請求就去緩存中讀取，使得請求能夠迅速響應。
- 並發： 在大並發的情況下，所有的請求直接訪問數據庫，數據庫會出現連接異常。這個時候，就需要使用redis做一個緩沖操作，讓請求先訪問到Redis，而不是直接訪問數據庫。
更多關於“為什么要使用Redis”，博客園【原創】分布式之redis復習精講 ，這篇博文關於Redis的講解我覺得超贊，謝謝作者的耐心分享。
Spring Boot 2.x如何整合Redis
我使用的Spring Boot版本是2.1.0，根據網上的一些舊的教程進行整合Redis 3.2的時候，會有許多地方有錯誤提示。這是因為Spring Boot 2.x做了一些修改，這些修改對使用而有沒有影響呢？我們改怎么整合呢？下面就進入正式的整合過程。
1. pom.xnl引入依賴
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
現在會提示Project build error: 'dependencies.dependency.version' for org.springframework.boot:spring-boot-starter-redis:jar is missing. 提示spring-boot-starter-redis:jar找不到。
這是因為Spring Boot 1.4之后不再支持spring-boot-starter-redis，更換spring-boot-starter-data-redis之后就可以了。如果你的pom文件報錯，請檢查是否將spring-boot-starter-redis 改成了spring-boot-starter-data-redis。
Spring Boot 2.x要使用下面的依賴：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2. application.properties添加配置文件
這是之前版本的配置文件：
# REDIS (RedisProperties) # Redis數據庫索引（默認為0） spring.redis.database=0 # Redis服務器地址 spring.redis.host=127.0.0.1 # Redis服務器連接端口 spring.redis.port=6379 # Redis服務器連接密碼（默認為空） spring.redis.password= # 連接池最大連接數（使用負值表示沒有限制） spring.redis.pool.max-active=8 # 連接池最大阻塞等待時間（使用負值表示沒有限制） spring.redis.pool.max-wait=-1 # 連接池中的最大空閑連接 spring.redis.pool.max-idle=8 # 連接池中的最小空閑連接 spring.redis.pool.min-idle=0 # 連接超時時間（毫秒） spring.redis.timeout=0
如果Spring Boot 2.x這么配置，有錯誤提示 Property 'spring.redis.pool.max-active' is Deprecated: Use 'spring.redis.jedis.pool.max-idle' instead. 'spring.redis.pool.max-active'已經被棄用了，推薦使用'spring.redis.jedis.pool.max-idle'來代替。
這是因為在2.x中配置redis的連接池信息時，不再使用spring.redis.pool的屬性，而是直接使用redis的lettuce或jedis客戶端來配置。現在的配置如下：
# REDIS (RedisProperties) # Redis數據庫索引（默認為0） spring.redis.database=0 # Redis服務器地址 spring.redis.host=127.0.0.1 # Redis服務器連接端口 spring.redis.port=6379 # Redis服務器連接密碼（默認為空） spring.redis.password= # 連接池最大連接數（使用負值表示沒有限制） spring.redis.jedis.pool.max-active=8 # 連接池最大阻塞等待時間（使用負值表示沒有限制） spring.redis.jedis.pool.max-wait=-1 # 連接池中的最大空閑連接 spring.redis.jedis.pool.max-idle=8 # 連接池中的最小空閑連接 spring.redis.jedis.pool.min-idle=0 # 連接超時時間（毫秒） spring.redis.timeout=0
3. 配置CacheManager
這是之前的RedisConfig配置類：
@Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { @Bean public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) { CacheManager cacheManager = new RedisCacheManager(redisTemplate); return cacheManager; } @Bean public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>(); redisTemplate.setConnectionFactory(factory); return redisTemplate; } }
現在這么寫會有報錯The constructor RedisCacheManager(RedisTemplate<capture#1-of ?,capture#2-of ?>) is undefined。
這是因為Spring Boot 2.x版本刪除了RedisCacheManager這個構造器， 也不可以通過之前的setDefaultExpiration方法設置默認的緩存過期時間等。
那么要怎樣構造一個 RedisCacheManager？看看官方文檔中怎么說？文檔地址：https://docs.spring.io/spring-data/data-redis/docs/2.1.x/reference/html/#new-in-2.1.0
官方文檔5.13.1. Support for the Spring Cache Abstraction（對Spring Cache Abstraction的支持）是關於怎么配置緩存的說明，我嘗試着翻譯了一下（藍色部分），英文水平有限，各位輕噴。
Spring Redis provides an implementation for the Spring cache abstraction through the org.springframework.data.redis.cache package. To use Redis as a backing implementation, add RedisCacheManager to your configuration, as follows:
Spring Redis在 org.springframework.data.redis.cache 包中為Spring緩存抽象提供了一個實現方案。要使用Redis作為支持實現，需要將RedisCacheManager添加到配置中，如下所示:
@Bean public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) { return RedisCacheManager.create(connectionFactory); }
RedisCacheManager behavior can be configured with RedisCacheManagerBuilder, letting you set the default RedisCacheConfiguration, transaction behavior, and predefined caches.
RedisCacheManager可以用 RedisCacheManagerBuilder 進行配置，允許自定義設置默認的RedisCacheConfiguration、事務行為和預定義的緩存。
RedisCacheManager cm = RedisCacheManager.builder(connectionFactory) .cacheDefaults(defaultCacheConfig()) .initialCacheConfigurations(singletonMap("predefined", defaultCacheConfig().disableCachingNullValues())) .transactionAware() .build();
As shown in the preceding example, RedisCacheManager allows definition of configurations on a per-cache basis.
正如上面的例子所示，RedisCacheManager 允許基於每個緩存進行配置。
The behavior of RedisCache created with RedisCacheManager is defined with RedisCacheConfiguration. The configuration lets you set key expiration times, prefixes, and RedisSerializer implementations for converting to and from the binary storage format, as shown in the following example:
RedisCacheManager創建RedisCache的行為被定義為RedisCacheConfiguration。該配置允許設置鍵值過期時間、前綴和RedisSerializer實現等屬性，以便與二進制存儲格式進行轉換，如下所示:
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofSeconds(1)) .disableCachingNullValues();
RedisCacheManager defaults to a lock-free RedisCacheWriter for reading and writing binary values. Lock-free caching improves throughput. The lack of entry locking can lead to overlapping, non-atomic commands for the putIfAbsent and clean methods, as those require multiple commands to be sent to Redis. The locking counterpart prevents command overlap by setting an explicit lock key and checking against presence of this key, which leads to additional requests and potential command wait times.
It is possible to opt in to the locking behavior as follows:
也可以選擇鎖定行為，如下所示：
RedisCacheManager cm = RedisCacheManager.build(RedisCacheWriter.lockingRedisCacheWriter())
.cacheDefaults(defaultCacheConfig())
...
By default, any key for a cache entry gets prefixed with the actual cache name followed by two colons. This behavior can be changed to a static as well as a computed prefix.
The following example shows how to set a static prefix:
以下示例顯示如何設置靜態前綴：
// static key prefix RedisCacheConfiguration.defaultCacheConfig().prefixKeysWith("( ͡° ᴥ ͡°)"); The following example shows how to set a computed prefix: // computed key prefix RedisCacheConfiguration.defaultCacheConfig().computePrefixWith(cacheName -> "¯\_(ツ)_/¯" + cacheName);
The following table lists the default settings for RedisCacheManager:
下表列出了RedisCacheManager的默認設置：
|
Setting
|
Value
|
|
Cache Writer
|
Non-locking
|
|
Cache Configuration
|
RedisCacheConfiguration#defaultConfiguration
|
|
Initial Caches
|
None
|
|
Trasaction Aware
|
No
|
The following table lists the default settings for RedisCacheConfiguration:
下表列出了RedisCacheConfiguration的默認設置：
|
Key Expiration
|
None
|
|
Cache null
|
Yes
|
|
Prefix Keys
|
Yes
|
|
Default Prefix
|
The actual cache name
|
|
Key Serializer
|
StringRedisSerializer
|
|
Value Serializer
|
JdkSerializationRedisSerializer
|
|
Conversion Service
|
DefaultFormattingConversionService with default cache key converters
|
對於Spring Boot 2.x，這里我使用RedisCacheConfiguration簡單配置一下緩存時間，完成RedisCacheManager的配置，代碼如下:
@Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { @Bean public CacheManager cacheManager(RedisConnectionFactory factory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(1)); RedisCacheManager cacheManager = RedisCacheManager.builder(factory).cacheDefaults(config).build(); return cacheManager; } }
4. Service層
在這里僅創建一個簡單的RedisService，來進行存取緩存數據。
@Service public class RedisService { @Resource private RedisTemplate<String, Object> redisTemplate; public void set(String key, Object value) { //更改在redis里面查看key編碼問題 RedisSerializer redisSerializer = new StringRedisSerializer(); redisTemplate.setKeySerializer(redisSerializer); ValueOperations<String, Object> vo = redisTemplate.opsForValue(); vo.set(key, value); } public Object get(String key) { ValueOperations<String, Object> vo = redisTemplate.opsForValue(); return vo.get(key); } }
5. Model層
實體類沒有修改，和之前文章里面用的一樣：
@Entity @Table(name = "user") public class User implements Serializable { private static final long serialVersionUID = 1L; @Id @GeneratedValue private Long id; @Column(name = "username") private String userName; @Column(name = "password") private String passWord; public User() { super(); } public User(String userName, String passWord) { super(); this.userName = userName; this.passWord = passWord; } public User(Long id, String userName, String passWord) { super(); this.id = id; this.userName = userName; this.passWord = passWord; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassWord() { return passWord; } public void setPassWord(String passWord) { this.passWord = passWord; } }
6. Controller層
@RestController @RequestMapping("user") public class UserController { @Autowired private UserRepository userRepository; @Autowired private RedisService redisService; @RequestMapping("/saveUser") public String saveUser(Long id, String userName, String passWord) { User user = new User(id, userName, passWord); redisService.set(id + "", user); return "success"; } @RequestMapping("/getUserById") public User getUserById(Long id) { User res = (User) redisService.get(id + ""); return res; } }
7. 測試
使用Postman進行測試，訪問http://localhost:8080//user/saveUser?id=12&userName=Howard&passWord=magician，添加了一個User。
看看Redis數據庫，使用get key查看，得到一個對象：
http://localhost:8080//user/getUserById?id=12，通過id獲取User。
這是過濾器和攔截器的日志信息，可以看到沒有進行MySQL數據庫的操作，直接從緩存中讀取，說明Redis配置生效了：
