Spring Boot實戰（六）：Spring Boot 2.x整合Redis

時間  2019-11-09
標籤 spring boot 實戰 2.x 整合 redis 欄目 Spring 简体版
原文   原文鏈接

最近在學習Spring Boot 2.x整合Redis，在這裏和你們分享一下，但願對你們有幫助。html

Redis是什麼

Redis 是開源免費高性能的key-value數據庫。有如下的優點（源於Redis官網）：java

  • 性能極高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s 。redis

  • 豐富的數據類型 – Redis支持二進制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 數據類型操做。spring

  • 原子 – Redis的全部操做都是原子性的，意思就是要麼成功執行要麼失敗徹底不執行。單個操做是原子性的。多個操做也支持事務，即原子性，經過MULTI和EXEC指令包起來。數據庫

  • 豐富的特性 – Redis還支持 publish/subscribe, 通知, key 過時等等特性。緩存

若是想了解更多關於Redis是什麼，能夠參考：Redis初識服務器

爲何要使用Redis

爲何要使用Redis？21世紀以來信息技術的飛速發展，咱們已經迎來了大數據時代，數據較以前爆炸增加，併發訪問量激增；由之帶來的就是系統設計由單體架構向分佈式架構的轉變和演進。對於緩存這個問題，若是系統是單體的系統，能夠在單個的JVM裏面進行本地緩存，例如能夠用HashMap來緩存一些數據。可是到了分佈式系統裏面，一個大系統裏面有不少個子系統，那他們之間如何共享緩存？這就須要Redis，用Redis來實現緩存系統。都說「時勢造英雄」，其實我想說Redis的大規模使用也是這個道理，用Redis作緩存系統從性能和併發兩方面考慮都是值得確定的。架構

  1. 性能：若是碰到須要執行耗時特別久，且結果不頻繁變更的SQL，就特別適合將運行結果放入緩存。這樣，後面的請求就去緩存中讀取，使得請求可以迅速響應。併發

  2. 併發： 在大併發的狀況下，全部的請求直接訪問數據庫，數據庫會出現鏈接異常。這個時候，就須要使用redis作一個緩衝操做，讓請求先訪問到Redis，而不是直接訪問數據庫。app

更多關於「爲何要使用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？看看官方文檔中怎麼說？文檔地址：docs.spring.io/spring-data…

官方文檔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.

RedisCacheManager默認是無鎖的，用於讀寫二進制值的RedisCacheWriter。無鎖緩存可提升吞吐量。缺乏鎖定可能致使putIfAbsent和clean方法的非原子命令重疊，由於這些方法須要向Redis發送多條命令。鎖對應程序經過設置顯式鎖定的key並檢查是否存在該key來防止命令重疊，這會致使額外的請求和潛在的命令等待時間。

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.

默認狀況下，緩存條目的任何key目以實際緩存名稱爲前綴，後跟兩個冒號。此行爲能夠更改成靜態前綴和計算前綴。

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層

使用緩存的狀況通常是這樣的：第一次訪問的時候先從數據庫讀取數據，而後將數據寫入到緩存，再次訪問同一內容的時候就從緩存中讀取，若是緩存中沒有則從數據庫中讀取。

添加緩存邏輯的時候，從數據庫中將內容讀取出來以後，先set入緩存，而後再從緩存中添加讀取行爲，若是緩存爲空則從數據庫中進行讀取。

在這裏僅建立一個簡單的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;
    }
    //省略getter和setter方法
    
}
複製代碼

6. Controller層

在user.Controller添加兩個測試方法，一個寫入Redis，一個從Redis讀取：

@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查看，獲得一個對象：

image

http://localhost:8080//user/getUserById?id=12，經過id獲取User。

image

這是過濾器和攔截器的日誌信息，能夠看到沒有進行MySQL數據庫的操做，直接從緩存中讀取，說明Redis配置生效了：

image

若是訪問以前的接口，是有操做數據庫的：

image

總結

以上就是Spring Boot 2.x整合Redis的全過程，和Spring Boot以前的版本在使用上有些細微的差異。

因爲水平有限，文中或多或少有欠妥之處，還望各位大佬指正！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程