Redis詳解 - SpringBoot整合Redis，RedisTemplate和註解兩種方式的使用

時間 2019-11-09

標籤 redis 詳解 springboot 整合 redistemplate 註解兩種方式使用欄目 Redis 简体版

原文原文鏈接

本文主要講 Redis 的使用，如何與 SpringBoot 項目整合，如何使用註解方式和 RedisTemplate 方式實現緩存。最後會給一個用 Redis 實現分佈式鎖，用在秒殺系統中的案例。html

更多 Redis 的實際運用場景請關注開源項目 coderiver 前端

項目地址：https://github.com/cachecats/...java

1、NoSQL 概述

什麼是 NoSQL ？

NoSQL(NoSQL = Not Only SQL )，意即「不只僅是SQL」，泛指非關係型的數據庫。git

爲何須要 NoSQL ？

隨着互聯網web2.0網站的興起，傳統的關係數據庫在應付web2.0網站，特別是超大規模和高併發的SNS類型的web2.0純動態網站已經顯得力不從心，暴露了不少難以克服的問題，而非關係型的數據庫則因爲其自己的特色獲得了很是迅速的發展。NoSQL數據庫的產生就是爲了解決大規模數據集合多重數據種類帶來的挑戰，尤爲是大數據應用難題。 -- 百度百科程序員

NoSQL 數據庫的四大分類

鍵值（key-value）存儲
列存儲
文檔數據庫
圖形數據庫

分類	相關產品	典型應用	數據模型	優勢	缺點
鍵值（key-value)	Tokyo、 Cabinet/Tyrant、Redis、Voldemort、Berkeley DB	內容緩存，主要用於處理大量數據的高訪問負載	一系列鍵值對	快速查詢	存儲的數據缺乏結構化
列存儲數據庫	Cassandra, HBase, Riak	分佈式的文件系統	以列簇式存儲，將同一列數據存在一塊兒	查找速度快，可擴展性強，更容易進行分佈式擴展	功能相對侷限
文檔數據庫	CouchDB, MongoDB	Web應用（與Key-Value相似，value是結構化的）	一系列鍵值對	數據結構要求不嚴格	查詢性能不高，並且缺少統一的查詢語法
圖形（Graph）數據庫	Neo4J, InfoGrid, Infinite Graph	社交網絡，推薦系統等。專一於構建關係圖譜	圖結構	利用圖結構相關算法	須要對整個圖作計算才能得出結果，不容易作分佈式集羣方案

NoSQL 的特色

易擴展
靈活的數據模型
大數據量，高性能
高可用

2、Redis 概述

Redis的應用場景

緩存
任務隊列
網站訪問統計
應用排行榜
數據過時處理
分佈式集羣架構中的 session 分離

Redis 安裝

網上有不少 Redis 的安裝教程，這裏就很少說了，只說下 Docker 的安裝方法：github

Docker 安裝運行 Redisweb

docker run -d -p 6379:6379 redis:4.0.8

若是之後想啓動 Redis 服務，打開命令行，輸入如下命令便可。redis

redis-server

使用前先引入依賴算法

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3、註解方式使用 Redis 緩存

使用緩存有兩個前置步驟spring

在 pom.xml 引入依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在啓動類上加註解 @EnableCaching

@SpringBootApplication
@EnableCaching
public class SellApplication {
    public static void main(String[] args) {
        SpringApplication.run(SellApplication.class, args);
    }
}

經常使用的註解有如下幾個

@Cacheable
屬性以下圖

用於查詢和添加緩存，第一次查詢的時候返回該方法返回值，並向 Redis 服務器保存數據。

之後調用該方法先從 Redis 中查是否有數據，若是有直接返回 Redis 緩存的數據，而不執行方法裏的代碼。若是沒有則正常執行方法體中的代碼。

value 或 cacheNames 屬性作鍵，key 屬性則能夠看做爲 value 的子鍵，一個 value 能夠有多個 key 組成不一樣值存在 Redis 服務器。

驗證了下，value 和 cacheNames 的做用是同樣的，都是標識主鍵。兩個屬性不能同時定義，只能定義一個，不然會報錯。

condition 和 unless 是條件，後面會講用法。其餘的幾個屬性不經常使用，其實我也不知道怎麼用…

@CachePut
更新 Redis 中對應鍵的值。屬性和 @Cacheable 相同
@CacheEvict
刪除 Redis 中對應鍵的值。

3.1 添加緩存

在須要加緩存的方法上添加註解 @Cacheable(cacheNames = "product", key = "123"),

cacheNames 和 key 都必須填，若是不填 key ，默認的 key 是當前的方法名，更新緩存時會由於方法名不一樣而更新失敗。

如在訂單列表上加緩存

@RequestMapping(value = "/list", method = RequestMethod.GET)
    @Cacheable(cacheNames = "product", key = "123")
    public ResultVO list() {

        // 1.查詢全部上架商品
        List<ProductInfo> productInfoList = productInfoService.findUpAll();

        // 2.查詢類目（一次性查詢）
        //用 java8 的特性獲取到上架商品的全部類型
        List<Integer> categoryTypes = productInfoList.stream().map(e -> e.getCategoryType()).collect(Collectors.toList());
        List<ProductCategory> productCategoryList = categoryService.findByCategoryTypeIn(categoryTypes);

        List<ProductVO> productVOList = new ArrayList<>();
        //數據拼裝
        for (ProductCategory category : productCategoryList) {
            ProductVO productVO = new ProductVO();
            //屬性拷貝
            BeanUtils.copyProperties(category, productVO);
            //把類型匹配的商品添加進去
            List<ProductInfoVO> productInfoVOList = new ArrayList<>();
            for (ProductInfo productInfo : productInfoList) {
                if (productInfo.getCategoryType().equals(category.getCategoryType())) {
                    ProductInfoVO productInfoVO = new ProductInfoVO();
                    BeanUtils.copyProperties(productInfo, productInfoVO);
                    productInfoVOList.add(productInfoVO);
                }
            }
            productVO.setProductInfoVOList(productInfoVOList);
            productVOList.add(productVO);
        }

        return ResultVOUtils.success(productVOList);
    }

可能會報以下錯誤

對象未序列化。讓對象實現 Serializable 方法便可

@Data
public class ProductVO implements Serializable {
    
    private static final long serialVersionUID = 961235512220891746L;

    @JsonProperty("name")
    private String categoryName;

    @JsonProperty("type")
    private Integer categoryType;

    @JsonProperty("foods")
    private List<ProductInfoVO> productInfoVOList ;
}

生成惟一的 id 在 IDEA 裏有一個插件：GenerateSerialVersionUID 比較方便。

重啓項目訪問訂單列表，在 rdm 裏查看 Redis 緩存，有 product::123 說明緩存成功。

3.2 更新緩存

在須要更新緩存的方法上加註解： @CachePut(cacheNames = "prodcut", key = "123")

注意

cacheNames 和 key 要跟 @Cacheable() 裏的一致，纔會正確更新。

@CachePut() 和 @Cacheable() 註解的方法返回值要一致

3.3 刪除緩存

在須要刪除緩存的方法上加註解：@CacheEvict(cacheNames = "prodcut", key = "123")，執行完這個方法以後會將 Redis 中對應的記錄刪除。

3.4 其餘經常使用功能

cacheNames 也能夠統一寫在類上面， @CacheConfig(cacheNames = "product") ，具體的方法上就不用寫啦。

@CacheConfig(cacheNames = "product")
public class BuyerOrderController {
    @PostMapping("/cancel")
    @CachePut(key = "456")
    public ResultVO cancel(@RequestParam("openid") String openid,
                           @RequestParam("orderId") String orderId){
        buyerService.cancelOrder(openid, orderId);
        return ResultVOUtils.success();
    }
}

Key 也能夠動態設置爲方法的參數

@GetMapping("/detail")
@Cacheable(cacheNames = "prodcut", key = "#openid")
public ResultVO<OrderDTO> detail(@RequestParam("openid") String openid,
                             @RequestParam("orderId") String orderId){
    OrderDTO orderDTO = buyerService.findOrderOne(openid, orderId);
    return ResultVOUtils.success(orderDTO);
}

若是參數是個對象，也能夠設置對象的某個屬性爲 key。好比其中一個參數是 user 對象，key 能夠寫成 key="#user.id"

緩存還能夠設置條件。

設置當 openid 的長度大於3時才緩存

@GetMapping("/detail")
@Cacheable(cacheNames = "prodcut", key = "#openid", condition = "#openid.length > 3")
public ResultVO<OrderDTO> detail(@RequestParam("openid") String openid,
                                 @RequestParam("orderId") String orderId){
    OrderDTO orderDTO = buyerService.findOrderOne(openid, orderId);
    return ResultVOUtils.success(orderDTO);
}

還能夠指定 unless 即條件不成立時緩存。#result 表明返回值，意思是當返回碼不等於 0 時不緩存，也就是等於 0 時才緩存。

@GetMapping("/detail")
@Cacheable(cacheNames = "prodcut", key = "#openid", condition = "#openid.length > 3", unless = "#result.code != 0")
public ResultVO<OrderDTO> detail(@RequestParam("openid") String openid,
                                 @RequestParam("orderId") String orderId){
    OrderDTO orderDTO = buyerService.findOrderOne(openid, orderId);
    return ResultVOUtils.success(orderDTO);
}

4、RedisTemplate 使用 Redis 緩存

與使用註解方式不一樣，註解方式能夠零配置，只需引入依賴並在啓動類上加上 @EnableCaching 註解就可使用；而使用 RedisTemplate 方式麻煩些，須要作一些配置。

4.1 Redis 配置

第一步仍是引入依賴和在啓動類上加上 @EnableCaching 註解。

而後在 application.yml 文件中配置 Redis

spring:
  redis:
    port: 6379
    database: 0
    host: 127.0.0.1
    password:
    jedis:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0
    timeout: 5000ms

而後寫個 RedisConfig.java 配置類

package com.solo.coderiver.user.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.net.UnknownHostException;


@Configuration
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

Redis 的配置就完成了。

4.2 Redis 的數據結構類型

Redis 能夠存儲鍵與5種不一樣數據結構類型之間的映射，這5種數據結構類型分別爲String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。

下面來對這5種數據結構類型做簡單的介紹：

結構類型	結構存儲的值	結構的讀寫能力
String	能夠是字符串、整數或者浮點數	對整個字符串或者字符串的其中一部分執行操做；對象和浮點數執行自增(increment)或者自減(decrement)
List	一個鏈表，鏈表上的每一個節點都包含了一個字符串	從鏈表的兩端推入或者彈出元素；根據偏移量對鏈表進行修剪(trim)；讀取單個或者多個元素；根據值來查找或者移除元素
Set	包含字符串的無序收集器(unorderedcollection)，而且被包含的每一個字符串都是獨一無二的、各不相同	添加、獲取、移除單個元素；檢查一個元素是否存在於某個集合中；計算交集、並集、差集；從集合裏賣弄隨機獲取元素
Hash	包含鍵值對的無序散列表	添加、獲取、移除單個鍵值對；獲取全部鍵值對
Zset	字符串成員(member)與浮點數分值(score)之間的有序映射，元素的排列順序由分值的大小決定	添加、獲取、刪除單個元素；根據分值範圍(range)或者成員來獲取元素

4.3 StringRedisTemplate 與 RedisTemplate

RedisTemplate 對五種數據結構分別定義了操做

redisTemplate.opsForValue();
操做字符串
redisTemplate.opsForHash();
操做hash
redisTemplate.opsForList();
操做list
redisTemplate.opsForSet();
操做set
redisTemplate.opsForZSet();
操做有序set

若是操做字符串的話，建議用 StringRedisTemplate 。

StringRedisTemplate 與 RedisTemplate 的區別

StringRedisTemplate 繼承了 RedisTemplate。
RedisTemplate 是一個泛型類，而 StringRedisTemplate 則不是。
StringRedisTemplate 只能對 key=String，value=String 的鍵值對進行操做，RedisTemplate 能夠對任何類型的 key-value 鍵值對操做。
他們各自序列化的方式不一樣，但最終都是獲得了一個字節數組，異曲同工，StringRedisTemplate 使用的是 StringRedisSerializer 類；RedisTemplate 使用的是 JdkSerializationRedisSerializer 類。反序列化，則是一個獲得 String，一個獲得 Object
二者的數據是不共通的，StringRedisTemplate 只能管理 StringRedisTemplate 裏面的數據，RedisTemplate 只能管理 RedisTemplate中的數據。

4.4 項目中使用

在須要使用 Redis 的地方，用 @Autowired 注入進來

@Autowired
RedisTemplate redisTemplate;
 
@Autowired
StringRedisTemplate stringRedisTemplate;

因爲項目中暫時僅用到了 StringRedisTemplate 與 RedisTemplate 的 Hash 結構，StringRedisTemplate 比較簡單就不貼代碼了，下面僅對操做 Hash 進行舉例。

關於 RedisTemplate 的詳細用法，有一篇文章已經講的很細很好了，我以爲不必再去寫了。傳送門

用 RedisTemplate 操做 Hash

package com.solo.coderiver.user.service.impl;

import com.solo.coderiver.user.dataobject.UserLike;
import com.solo.coderiver.user.dto.LikedCountDTO;
import com.solo.coderiver.user.enums.LikedStatusEnum;
import com.solo.coderiver.user.service.LikedService;
import com.solo.coderiver.user.service.RedisService;
import com.solo.coderiver.user.utils.RedisKeyUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class RedisServiceImpl implements RedisService {

    @Autowired
    RedisTemplate redisTemplate;

    @Autowired
    LikedService likedService;

    @Override
    public void saveLiked2Redis(String likedUserId, String likedPostId) {
        String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);
        redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED, key, LikedStatusEnum.LIKE.getCode());
    }

    @Override
    public void unlikeFromRedis(String likedUserId, String likedPostId) {
        String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);
        redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED, key, LikedStatusEnum.UNLIKE.getCode());
    }

    @Override
    public void deleteLikedFromRedis(String likedUserId, String likedPostId) {
        String key = RedisKeyUtils.getLikedKey(likedUserId, likedPostId);
        redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);
    }

    @Override
    public void incrementLikedCount(String likedUserId) {
        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedUserId, 1);
    }

    @Override
    public void decrementLikedCount(String likedUserId) {
        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, likedUserId, -1);
    }

    @Override
    public List<UserLike> getLikedDataFromRedis() {
        Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED, ScanOptions.NONE);
        List<UserLike> list = new ArrayList<>();
        while (cursor.hasNext()) {
            Map.Entry<Object, Object> entry = cursor.next();
            String key = (String) entry.getKey();
            //分離出 likedUserId，likedPostId
            String[] split = key.split("::");
            String likedUserId = split[0];
            String likedPostId = split[1];
            Integer value = (Integer) entry.getValue();

            //組裝成 UserLike 對象
            UserLike userLike = new UserLike(likedUserId, likedPostId, value);
            list.add(userLike);

            //存到 list 後從 Redis 中刪除
            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);
        }

        return list;
    }

    @Override
    public List<LikedCountDTO> getLikedCountFromRedis() {
        Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, ScanOptions.NONE);
        List<LikedCountDTO> list = new ArrayList<>();
        while (cursor.hasNext()) {
            Map.Entry<Object, Object> map = cursor.next();
            //將點贊數量存儲在 LikedCountDT
            String key = (String) map.getKey();
            LikedCountDTO dto = new LikedCountDTO(key, (Integer) map.getValue());
            list.add(dto);
            //從Redis中刪除這條記錄
            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, key);
        }
        return list;
    }
}

5、Redis 實現分佈式鎖

講完了基礎操做，再說個實戰運用，用Redis 實現分佈式鎖。

實現分佈式鎖以前先看兩個 Redis 命令：

SETNX

將key設置值爲value，若是key不存在，這種狀況下等同SET命令。當key存在時，什麼也不作。SETNX是」SET if Not eXists」的簡寫。

返回值

Integer reply, 特定值:
- 1 若是key被設置了
- 0 若是key沒有被設置

例子

redis> SETNX mykey "Hello"
(integer) 1
redis> SETNX mykey "World"
(integer) 0
redis> GET mykey
"Hello"
redis>

GETSET

自動將key對應到value而且返回原來key對應的value。若是key存在可是對應的value不是字符串，就返回錯誤。

設計模式

GETSET能夠和INCR一塊兒使用實現支持重置的計數功能。舉個例子：每當有事件發生的時候，一段程序都會調用INCR給key mycounter加1，可是有時咱們須要獲取計數器的值，而且自動將其重置爲0。這能夠經過GETSET mycounter 「0」來實現：
```
INCR mycounter
GETSET mycounter "0"
GET mycounter
```
返回值

bulk-string-reply: 返回以前的舊值，若是以前Key不存在將返回nil。

例子
```
redis> INCR mycounter
(integer) 1
redis> GETSET mycounter "0"
"1"
redis> GET mycounter
"0"
redis>
```

這兩個命令在 java 中對應爲 setIfAbsent 和 getAndSet

分佈式鎖的實現：

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
@Slf4j
public class RedisLock {

    @Autowired
    StringRedisTemplate redisTemplate;

    /**
     * 加鎖
     * @param key
     * @param value 當前時間 + 超時時間
     * @return
     */
    public boolean lock(String key, String value){
        if (redisTemplate.opsForValue().setIfAbsent(key, value)){
            return true;
        }

        //解決死鎖，且當多個線程同時來時，只會讓一個線程拿到鎖
        String currentValue = redisTemplate.opsForValue().get(key);
        //若是過時
        if (!StringUtils.isEmpty(currentValue) &&
                Long.parseLong(currentValue) < System.currentTimeMillis()){
            //獲取上一個鎖的時間
            String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
            if (StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue)){
                return true;
            }
        }

        return false;
    }

    /**
     * 解鎖
     * @param key
     * @param value
     */
    public void unlock(String key, String value){

        try {
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)){
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        }catch (Exception e){
            log.error("【redis鎖】解鎖失敗, {}", e);
        }
    }
}

使用：

/**
 * 模擬秒殺
 */
public class SecKillService {

    @Autowired
    RedisLock redisLock;

    //超時時間10s
    private static final int TIMEOUT = 10 * 1000;

    public void secKill(String productId){
        long time = System.currentTimeMillis() + TIMEOUT;
        //加鎖
        if (!redisLock.lock(productId, String.valueOf(time))){
            throw new SellException(101, "人太多了，等會兒再試吧~");
        }

        //具體的秒殺邏輯

        //解鎖
        redisLock.unlock(productId, String.valueOf(time));
    }
}

更多 Redis 的具體使用場景請關注開源項目 CodeRiver，致力於打造全平臺型全棧精品開源項目。

coderiver 中文名河碼，是一個爲程序員和設計師提供項目協做的平臺。不管你是前端、後端、移動端開發人員，或是設計師、產品經理，均可以在平臺上發佈項目，與志同道合的小夥伴一塊兒協做完成項目。

coderiver河碼相似程序員客棧，但主要目的是方便各細分領域人才之間技術交流，共同成長，多人協做完成項目。暫不涉及金錢交易。

計劃作成包含 pc端（Vue、React）、移動H5（Vue、React）、ReactNative混合開發、Android原生、微信小程序、java後端的全平臺型全棧項目，歡迎關注。

項目地址：https://github.com/cachecats/...

您的鼓勵是我前行最大的動力，歡迎點贊，歡迎送小星星✨ ~