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
閱讀源碼：
@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 的配置文件和持久化。