Redis系列（三）Redis的事務和Spring Boot整合-有解無憂

NoSQL 開發中或多或少都會用到，也是面試必問知識點，最近這幾天的面試每一場都問到了，但是感徑訓答的并不好，還有很多需要梳理的知識點，這里通過幾篇 Redis 筆記整個梳理一遍，后面再加上面試題，

Redis 系列：

Redis系列（一）Redis入門
Redis系列（二）Redis的8種資料型別
Redis系列（三）Redis的事務和Spring Boot整合
Redis系列（四）Redis組態檔和持久化
Redis系列（五）發布訂閱模式、主從復制和哨兵模式
Redis系列（六）Redis 的快取穿透、快取擊穿和快取雪崩
Redis系列（七）Redis面試題
Redis命令參考

1、事務

Redis 事務的本質：一組命令的集合！一個事務中的所有命令都會被序列化，在事務執行程序中，會按照順序執行，

一次性、順序性、排他性的執行一組命令，

Redis 事務沒有隔離級別的概念，

所有的命令在事務中，并沒有直接被執行，只有發起執行命令的時候才會執行（exec），

Redis 單條命令是保證原子性的，但是事務不保證原子性，

Redis 事務的命令：

開啟事務：multi
命令入隊
執行事務：exec
撤銷事務：discard

1、正常執行事務

127.0.0.1:6379> multi		# 開啟事務
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec			# 執行事務
1) OK
2) OK
3) "v2"
4) OK
127.0.0.1:6379>

2、放棄事務

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set m1 n1
QUEUED
127.0.0.1:6379> set m2 n2
QUEUED
127.0.0.1:6379> DISCARD		# 放棄事務
OK
127.0.0.1:6379> get m1		# 事務佇列中命令都不會被執行
(nil)

編譯型例外：命令有錯，事務中所有的命令都不會被執行

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> setget k3 v3		# 錯誤的命令
(error) ERR unknown command `setget`, with args beginning with: `k3`, `v3`, 
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> exec		# 執行事務報錯
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k4		# 所有的命令都不會被執行
(nil)
127.0.0.1:6379>

運行時例外：如果事務中某條命令執行結果報錯，其他命令是可以正常執行的，錯誤命令拋出例外

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1		# 會執行失敗
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> exec
1) (error) ERR value is not an integer or out of range		# 第一條命令執行失敗，其余的正常執行
2) OK
3) OK
4) "v3"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379>

3、監視 Watch （面試常問）

悲觀鎖：很悲觀，認為什么時候都會出問題，無論什么都會加鎖，影響效率，實際情況一般會使用樂觀鎖，

樂觀鎖：很樂觀，認為什么時候都不會出現問題，所以不上鎖，更新資料的時候回判斷一下，在此期間是否修改過監視的資料，也就是獲取 version，

首先要了解redis事務中watch的作用，watch命令可以監控一個或多個鍵，一旦其中有一個鍵被修改（或洗掉），之后的事務就不會執行，監控一直持續到exec命令（事務中的命令是在exec之后才執行的，所以在multi命令后可以修改watch監控的鍵值），假設我們通過watch命令在事務執行之前監控了多個Keys，倘若在watch之后有任何Key的值發生了變化，exec命令執行的事務都將被放棄，同時回傳Null multi-bulk應答以通知呼叫者事務執行失敗，

所以，需要注意的是watch監控鍵之后，再去操作這些鍵，否則watch可能會起不到效果，

Redis 監視測驗

正常測驗：

127.0.0.1:6379> set money 100		
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money		# 監視 money 物件
OK
127.0.0.1:6379> multi		# 事務正常結束，執行期間，money 沒有變動，這個時候就能執行成功了
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20
127.0.0.1:6379>

測驗多執行緒修改值，使用 watch 可以當做 Redis 的樂觀鎖操作，

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 10
OK
127.0.0.1:6379> watch money	# 監視 money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> DECRBY out 10
QUEUED
127.0.0.1:6379> exec		# 執行之前，在另外一個執行緒 B 中修改 money 的值，下面就是執行失敗，
(nil)
127.0.0.1:6379>

B 執行緒：

[root@itzhouc bin]# redis-cli -p 6379
127.0.0.1:6379> set money 30
OK

如果修改失敗，獲取最新的值就好，

127.0.0.1:6379> UNWATCH		# 事務執行失敗，先解鎖
OK
127.0.0.1:6379> WATCH money		# 獲取最新的值，再次監視，相當于 MySQL 中的 select version
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 1
QUEUED
127.0.0.1:6379> INCRBY out 1
QUEUED
127.0.0.1:6379> exec		# 執行的時候會對比監視的值，如果發生變化會執行失敗，
1) (integer) 29
2) (integer) 11
127.0.0.1:6379>

2、Jedis

使用 Java 操作 Redis ，Jedis 是 Redis 官方推薦的Java 鏈接開發工具，是 Java 操作 Redis 的中間件，

1、匯入依賴

<dependencies>
    <!-- jeids -->
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>

    <!-- fastjson -->
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.68</version>
    </dependency>
</dependencies>

2、測驗：啟動本地 Windows 版本的 Redis

package cn.itzhouq;

import redis.clients.jedis.Jedis;

public class TestPing {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379, 10);
        System.out.println(jedis.ping()); // PONG
    }
}

事務

package cn.itzhouq;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * 測驗事務
 */
public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.flushDB();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "xxx");

        // 開啟事務
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();

        try {
            multi.set("user1", result);
            multi.set("user2", result);
            int i = 1 / 0; // 模擬例外
            multi.exec(); // 執行事務
        } catch (Exception e) {
            multi.discard(); // 放棄事務
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1")); // 正常執行時{"name":"xxx","hello":"world"}   // null
            System.out.println(jedis.get("user1"));
            jedis.close(); // 關閉鏈接
        }
    }
}

3、Spring Boot 整合

Spring Data 也是和 Spring Boot 齊名的專案，

說明：在 Spring Boot 2.x 之后，原來的 Jedis 被替換為了 lettuce，

Jedis：采用的直連，多執行緒操作的話是不安全的，如果想要避免不安全的話，使用 Jedis Pool ，更像 BIO 模式，

lettuce ：采用 netty ，實體可以在多個執行緒中共享，不存在執行緒不安全的情況，可以減少執行緒鏈接，更像 NIO 模式，

# Spring Boot 所有的配置類，都有一個自動配置類  RedisTemplate
# 自動配置類都會系結一個 properties 組態檔，  RedisProperties

閱讀原始碼：

1588351399447

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    ) // 我們可以自己定義一個 RedisTemplate 來替換這個默認的，
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 默認的 RedisTemplate 沒有過多的設定， Redis 物件都是需要序列化的，
        // 兩個泛型都是 Object, Object 的型別，我們需要強制裝換為 <String, Obejct>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean // 由于 String 型別是 Redis 中最常用的，所以單獨提出來一個 bean .
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

測驗一下：

1、匯入依賴：

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

2、配置連接

# 配置 Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

3、測驗

package cn.itzhouq;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void contextLoads() {
        // 除了基本的操作，我們常用的方法都可以直接通過 redisTemplate 操作，比如事務和 CRUD
        redisTemplate.opsForValue().set("name", "xiaoming");
        System.out.println(redisTemplate.opsForValue().get("name")); // xiaoming
    }
}

看一下原始碼：RedisTemplate.class

// 序列化配置
@Nullable
private RedisSerializer keySerializer = null;
@Nullable
private RedisSerializer valueSerializer = null;
@Nullable
private RedisSerializer hashKeySerializer = null;
@Nullable
private RedisSerializer hashValueSerializer = null;
private RedisSerializer<String> stringSerializer = RedisSerializer.string();

public void afterPropertiesSet() {
    super.afterPropertiesSet();
    boolean defaultUsed = false;
    if (this.defaultSerializer == null) {
        // 默認使用了 JDK 的序列化，會使得字串轉義
        this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
    }

    // ...
}

我們使用 Json 序列化，所以需要自定義配置類

1、序列化

撰寫一個物體類 User，測驗序列化，

package cn.itzhouq.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Component
@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    private String name;
    private int age;
}

測驗序列化：

 @Test
public void test() throws JsonProcessingException {
    User user = new User("xiaoming", 3);
    redisTemplate.opsForValue().set("user", user);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

拋出例外：

Caused by: java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [cn.itzhouq.pojo.User]
	at org.springframework.core.serializer.DefaultSerializer.serialize(DefaultSerializer.java:43)
	at org.springframework.core.serializer.support.SerializingConverter.convert(SerializingConverter.java:63)
	... 35 more

DefaultSerializer requires a Serializable默認的序列化需要物體類實作序列化介面，所以修改 User：

public class User implements Serializable {
    private String name;
    private int age;
}

結果：

User(name=xiaoming, age=3)

結果顯示正常，但是控制臺還是轉義的，

127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04user"
127.0.0.1:6379>

使用 jackson 的序列化：

@Test
public void test() throws JsonProcessingException {
    // 一般開發中都會使用 json 來傳遞物件
    User user = new User("xiaoming", 3);
    String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user", jsonUser);
    System.out.println(redisTemplate.opsForValue().get("user")); // {"name":"xiaoming","age":3}
}

無論 User 是否實作了 Serializable 介面，控制臺結果顯示正常，但是客戶端中查看還是被轉義了，

如果不想使用 JDK 的序列化，可以自己撰寫 RedisTemplate，

2、自定義RedisTemplate

package cn.itzhouq.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * 撰寫的自己的 RedisTemplate
 */
@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 為了開發方便，一般使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

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

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key 采用 String 的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的 key 也采用 String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 Jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 value 序列化方式采用 Jackson
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

注入和測驗：

@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;

@Test
public void test() throws JsonProcessingException {
    // 一般開發中都會使用 json 來傳遞物件
    User user = new User("xiaoming", 3);
    String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user", jsonUser);
    System.out.println(redisTemplate.opsForValue().get("user")); // {"name":"xiaoming","age":3}
}

客戶端中查看：

127.0.0.1:6379> keys *
1) "user"
127.0.0.1:6379>

這個時候的物件就沒有被轉義，

下一篇筆記將介紹 Redis 的組態檔和持久化，

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/3171.html

標籤：NoSQL

上一篇：Redis系列（二）Redis的8種資料型別

下一篇：Redis系列（四）Redis組態檔和持久化