NoSQL 开发中或多或少都会用到,也是面试必问知识点。最近这几天的面试每一场都问到了。但是感觉回答的并不好,还有很多需要梳理的知识点。这里通过几篇 Redis 笔记整个梳理一遍,后面再加上面试题。
Redis 事务的本质:一组命令的集合!一个事务中的所有命令都会被序列化,在事务执行过程中,会按照顺序执行。
一次性、顺序性、排他性的执行一组命令。
Redis 事务没有隔离级别的概念。
所有的命令在事务中,并没有直接被执行,只有发起执行命令的时候才会执行(exec)。
Redis 单条命令是保证原子性的,但是事务不保证原子性。
Redis 事务的命令:
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>
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>
悲观锁:很悲观,认为什么时候都会出问题,无论什么都会加锁。影响效率,实际情况一般会使用乐观锁。
乐观锁:很乐观,认为什么时候都不会出现问题,所以不上锁。更新数据的时候回判断一下,在此期间是否修改过监视的数据,也就是获取 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>
使用 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(); // 关闭链接 } } }
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 序列化,所以需要自定义配置类
编写一个实体类 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。
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 的配置文件和持久化。