从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】

文章目录

  • 从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】
    • redis通用命令
    • resp图形化界面连接redis
    • String类型的常用命令
      • key的层级结构
    • Hash类型的常见命令
    • LIst类型的常见命令
    • Set类型的常见命令
    • SortedSet类型常用命令
    • Redis的java客户端
      • Jedis
      • Jedis连接池
      • SpringDataRedis
    • Redis的实战运用场景
      • 基于Redis实现共享session登录
      • Redis缓存
      • 缓存更新策略
      • 缓存穿透
      • 缓存雪崩
      • 缓存击穿
      • 超卖问题
      • 乐观锁和悲观锁
      • 分布式锁

redis通用命令

  • KEYS age:查询所有键为key的键,age可以使用通配符,生产环境下数据量庞大,一般不建议使用

  • 从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第1张图片

  • DEL key1 key2 …:删除指定的键,可以同时删除多个,返回删除的个数

  • EXISTS key1 key2 …:判断键是否存在,可以同时查询多个,有几个键存在就返回几

  • 从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第2张图片

  • EXPIRE key 时间(秒):给指定键加一个销毁时间,时间到了之后这个键会自动销毁

  • 从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第3张图片

  • TTL key:查看一个指定键的有效期,有效期到了之后返回-2,没有设置有效期的键返回-1

  • 从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第4张图片

resp图形化界面连接redis

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第5张图片

在连接redis时,以上ip和端口正确的,但是出现连接不上,原因有可能是两种:

  • redis服务端还未开启,可以使用systemctl status redis 命令查看redis的运行状态,检查为未开启状态时,可以使用systemctl start redis 命令启动redis
  • Linux系统的防火墙未关闭,在LInux系统上面使用redis需要将Linux的防火墙关闭,这样才能正常连接,CentOS7可以使用systemctl stop firewalld.service 命令关闭防火墙

String类型的常用命令

在FinalShell或者虚拟机终端使用命令时,需要先连接上服务端才能对redis进行操作,先使用redis-cli 命令创建一个命令行客户端连接redis,再使用auth 密码,输入密码,之后便可以在终端命令行中使用redis命令了

在这里插入图片描述

String类型有三种格式,分别是字符串、int、float

String类型的常用命令有:

  • SET key val:添加或修改指定键值对,当输入的键存在的话就是修改,不存在就是添加

在这里插入图片描述

  • GET key:根据指定的key获取String类型的value

在这里插入图片描述

  • MSET key1 1 key2 2 key3 3…:同时添加多个键值对

在这里插入图片描述

  • MGET key1 key2 key3 …:同时获取多个键值对的值

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第6张图片

  • INCR key :让一个整形的key自增1

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第7张图片

  • INCRBY key 自增数字:让一个整型的键自增指定数字,例如让k2自增2
    从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第8张图片

  • INCRBYFLOAT key 自增数字:让一个浮点型的数字自增指定步长

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第9张图片

  • SETNX key val :添加一个String类型的键值对,前提是这个键值对不存在,如果存在则添加失败

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第10张图片

  • SETEX key 时间 val:添加一个String类型的键值对,并且指定有效期

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第11张图片

key的层级结构

Redis允许有多个单词形成层级结构,多个单词使用 ‘:’ 隔开,格式如下:

项目名:业务名:类型:id

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第12张图片

在resp中查看

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第13张图片

根据我们输入的层级关系,redis会自动帮我们层级分类,这样就克服了区分不同类型的key的问题了

Hash类型的常见命令

什么是Hash类型,Hash类型,也叫散列,类似于java中的HashMap结构,String类型是将对象序列化成JSON字符串后存储,但需要修改某个字段时很不方便,Hash结构可以将字段单独存储,可以对单个字段做curd

String结构:
从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第14张图片

Hash结构:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第15张图片

Hash结构的常见命令和String类型的常见命令相似,基本上都是在String命令的基础上加上H,代表操作的时Hash结构

  • HSET key field value:添加或修改key中的field的值

在这里插入图片描述

  • HGET key field:获取一个hash类型的key的field的值

在这里插入图片描述

  • HMSET key field1 value1 field2 value2 …:批量添加Hash类型的的key的field的值

在这里插入图片描述

  • HMGET key field1 field2 field3 …:批量查看key值的field的值,如果查看的field不存在,则显示null

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第16张图片

  • HGETALL key:获取key中的所有field和value,类似于java中的entryset,获取所有的键值对

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第17张图片

  • HKEYS key:获取key中的所有field,类似于Java中的根据键获取值

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第18张图片

  • HVALS key:获取key中的所有value,类似于java中的获取键的方法

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第19张图片

  • HINCRBY key field:使一个键中的某一个字段自增指定步长

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第20张图片

  • HSETNCX key field value:添加一个Hash类型的的key和field的值,前提是这个field不存在,否则添加失败

在这里插入图片描述

LIst类型的常见命令

Redis中的List类型是一个双向链表结构,具有有序可重复、插入删除快、查询速度一般的特点。

List的常见命令:

  • LPUSH key element … :向链表的左侧插入一个或多个元素
  • RPUSH key element … :向链表的右侧插入一个或多个元素

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第21张图片

resp显示:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第22张图片

  • LPOP key count:删除并返回左侧的count个元素,count可以不写,返回左侧第一个元素,若没有元素则返回nil
  • RPOP key count:删除并返回右侧的count个元素,count可以不写,返回右侧第一个元素,若没有元素则返回nil

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第23张图片

  • LRANGE key star end:返回某一角标内的所有元素,包括该角标

在这里插入图片描述

  • BLPOP key timeout:与LPOP类似,增加了一个等待时间,timeout秒之后,若找不到元素,则返回nil,BLPOP一样

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第24张图片

Set类型的常见命令

Redis的Set集合和java中的HashSet类似,可以看做是一个value为null的HashMap。

Set类型的常见命令:

  • SADD key member …:向Set中添加一个或者多个元素

在这里插入图片描述

  • SREM key member:删除set集合中的指定元素

在这里插入图片描述

  • SCARD key :返回set集合中的元素个数

在这里插入图片描述

  • SISMEMBER key member:判断一个元素是否存在于set中。存在返回1,不存在返回0

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第25张图片

  • SMEMBERS key:获取key中的所有元素

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第26张图片

  • SINTER key1 key2 …:求key1和key2的交集

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第27张图片

  • SDIFF key1 key2 …:求key1和key2的差集
    从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第28张图片
    从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第29张图片

SortedSet类型常用命令

SortedSet是Redis中的一个可排序的set集合,SortedSet集合中的每一个元素都有一个score属性,可以基于score属性对元素进行排序,底层是跳表加哈希表

SortedSet类型常见命令:

  • ZADD key score member:添加一个或多个元素到sortedset集合中,如果已经存在则跟更新其score值

在这里插入图片描述

resp中显示:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第30张图片

  • ZREM key member:删除key中的一个指定元素

在这里插入图片描述

  • ZSCORE key member:获取key中指定member的score值

在这里插入图片描述

  • ZRANK key member:获取key的member的score的排名,也就是下标,从0开始

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第31张图片

  • ZCARD key:获取key中的元素个数

在这里插入图片描述

  • ZCOUNT key min max:统计score在范围内所有元素的个数

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第32张图片

  • ZINCRBY key increment member:让key中的member的score自增increment步长

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第33张图片

  • ZRANGE key min max:按照score排序后,获取指定排名范围内的元素,member值,与zcount格式相同,zount是统计个数,而zrange是统计元素

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第34张图片

  • ZRANGEBYSCORE key min max:根据score的排序,获取score范围内的元素

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第35张图片

  • ZDIFF、ZINTER、ZUNION:求差集、交集、并集

Redis的java客户端

Jedis

Jedis是以Redis命令作为方法名称的,学习成本低,简单使用,但是Jedis实例是线程不安全的,多线程环境下需要基于连接池来使用。

Jedis官方网址:GitHub - redis/jedis: Redis Java client

Jedis的基本使用:

  1. 引入依赖
 
        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>4.4.3version>
        dependency>
  1. 建立连接
    @BeforeEach
    void setUp(){
        //建立连接
        jedis = new Jedis("192.168.190.134", 6379);
        //设置密码
        jedis.auth("123456");
        //选择库
        jedis.select(0);
    }
  1. 测试连接
 	@Test
	//String类型
    void contextLoads() {
        //插入数据
        String result = jedis.set("name", "lisi");
        System.out.println("result="+result);
        //获取数据
        String name = jedis.get("name");
        System.out.println("mame="+name);
    }
   @Test
   //Hash类型
    void testHash(){
        //插入数据
        jedis.hset("user:1","name","zhangsan");
        jedis.hset("user:1","age","18");
        //获取数据
        Map<String, String> stringStringMap = jedis.hgetAll("user:1");
        System.out.println(stringStringMap);
    }

  1. 释放资源
	@AfterEach
    void tearDown(){
        //释放资源
        if (jedis!=null){
            jedis.close();
        }
    }

补充: @BeforeEach和@AfterEach注解的作用:分别为在执行测试类中的方之前和执行完成之后执行该方法

Jedis连接池

因为Jedis本身是线程不安全的,并且频繁的创建和销毁连接会有性能消耗,因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。

编写连接池类

package com.lbc.redisdemo.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @program: Redisdemo
 * @Date: 2023/8/4 22:05
 * @Author: Huang
 * @Description:
 */
public class JedisConnectionFactory {
    private static final JedisPool jedisPoll;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //设置等待时长 ms
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPoll = new JedisPool(jedisPoolConfig, "192.168.190.134", 6379, 1000, "123456");
    }
    //获取jedis对象
    public static Jedis getJedis(){
        return jedisPoll.getResource();
    }
}

测试类

package com.lbc.redisdemo;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lbc.redisdemo.pojo.User;
import com.lbc.redisdemo.util.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import redis.clients.jedis.Jedis;


@SpringBootTest
class RedisdemoApplicationTests {
    private Jedis jedis;
    @BeforeEach
    void setUp(){
        //建立连接
//        jedis = new Jedis("192.168.190.134", 6379);
        jedis = JedisConnectionFactory.getJedis();
        //设置密码
        jedis.auth("123456");
        //选择库
        jedis.select(0);
    }

    @Test
    void contextLoads() {
        //插入数据
        String result = jedis.set("name", "lisi");
        System.out.println("result="+result);
        //获取数据
        String name = jedis.get("name");
        System.out.println("mame="+name);
    }
    @Test
    void testHash(){
        //插入数据
        jedis.hset("user:1","name","zhangsan");
        jedis.hset("user:1","age","18");
        //获取数据
        Map<String, String> stringStringMap = jedis.hgetAll("user:1");
        System.out.println(stringStringMap);
    }   
   	@AfterEach
    void tearDown(){
        //释放资源
        if (jedis!=null){
            jedis.close();
        }
    }

}

SpringDataRedis

SpringData是Spring中数据操作的模块,包含对各种数据的集成,其中对Redis集成的模块就叫SpringDataRedis。

官网:Spring Data Redis

SpringDataRedis的优势:

  • 提供了对不同Redis客户端的整合(Lettuce和Jedis)
  • 提供了RedisTemplate统一api来操作Redis
  • 支持Redis的发布订阅模型
  • 支持Redis哨兵和Redis集群
  • 支持基于Lettuce的响应式编程
  • 支持基于JDK、JSON、字符串、Spring对象的数据序列化和反序列化
  • 支持基于Redis的JDKCollection实现

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第36张图片

SpringDataRedis基本使用

  1. 导入依赖
 
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

        
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
        dependency>
  1. 配置文件
spring:
  redis:
    host: 192.168.190.141
    port: 6379
    password: 123456
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100
  1. 编写测试类
package com.lbc.redisdemo;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lbc.redisdemo.pojo.User;
import com.lbc.redisdemo.util.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

@SpringBootTest
class RedisdemoApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void testString(){
        //插入String的一条数据
        redisTemplate.opsForValue().set("name","Jack");
        //读取一条String类型的数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);

        redisTemplate.opsForValue().set("User:10",new User("zhansan","19"));
        User o = (User) redisTemplate.opsForValue().get("User:10");
        System.out.println("o="+o);
    }
    @Test
    void testHash2(){
        //插入数据
        redisTemplate.opsForHash().put("User:30","name","zhangsan");
        redisTemplate.opsForHash().put("User:30","age","21");
        //获取数据
        //获取所有键值对
        Map entries = redisTemplate.opsForHash().entries("User:30");
        //获取所有键
        Set keys = redisTemplate.opsForHash().keys("User:30");
        //获取所有值
        List values = redisTemplate.opsForHash().values("User:30");
        System.out.println("键值对="+entries);
        System.out.println("键="+keys);
        System.out.println("值="+values);
    }
}

在RedisTemplate中,对String类型的操作方法名与redis的名字一致,但是对Hash类型的操作是与Map集合的相似,因为Hash类型与java的Map类型一样的键值对存储结构。

RedisTemplate可以接收任意的Object作为值写入Redis,只不过写入之前会把Object序列化为字节形式,默认是采用JDK序列化,得到的结果是一段长字符,这样可读性差并且内存的占用比较大。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第37张图片

为解决上述问题,我们可以自定义RedisTemplate的序列化形式,编写的配置类如下代码

package com.lbc.redisdemo.config;

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * @program: Redisdemo
 * @Date: 2023/8/7 9:45
 * @Author: Huang
 * @Description:
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        //创建Template
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置序列化工具
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //key和hashKey采用String序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        //value和hashValue采用JSON序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }

}

重新运行上段测试代码,获得的结果为:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第38张图片

图中还有一段字段为该对象的类名,我们发现类型的所占内存甚至比我们存储的信息还要大,这是我们不希望看到的,于是我们需要手动的对对象进行序列化共和反序列化,代码如下:

package com.lbc.redisdemo;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lbc.redisdemo.pojo.User;
import com.lbc.redisdemo.util.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

@SpringBootTest
class RedisdemoApplicationTests {
    private Jedis jedis;
    @Autowired
    private RedisTemplate redisTemplate;
    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    void testString() throws JsonProcessingException {
        //创建一个对象
        User user = new User("zhangsan","20");
        //手动序列化
        String json = mapper.writeValueAsString(user);
        System.out.println(json);
        redisTemplate.opsForValue().set("User:20",json);
        //获取数据
        String jsonUser = (String) redisTemplate.opsForValue().get("User:10");
        System.out.println(jsonUser);
        //手动反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println(user1);
    }
    @Test
    void testHash2(){
        //插入数据
        redisTemplate.opsForHash().put("User:30","name","zhangsan");
        redisTemplate.opsForHash().put("User:30","age","21");
        //获取数据
        //获取所有键值对
        Map entries = redisTemplate.opsForHash().entries("User:30");
        //获取所有键
        Set keys = redisTemplate.opsForHash().keys("User:30");
        //获取所有值
        List values = redisTemplate.opsForHash().values("User:30");
        System.out.println("键值对="+entries);
        System.out.println("键="+keys);
        System.out.println("值="+values);
    }
}

运行获得结果:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第39张图片

Redis的实战运用场景

基于Redis实现共享session登录

session共享问题 :多台Tomcat不会共享session存储空间,当多个请求切换到不同的Tomcat服务时会造成数据丢失的问题。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第40张图片

举个例子,当我们在使用短信验证码登录时,我们先点击发送验证码,这个请求由Tomcat1接收处理了,而产生的验证码存储在Tomcat1的session中,当我们输入验证码点击登录时,由Tomcat2接收处理,当我们需要获取先前产生的验证码与用户输入的验证码进行校验时,这时我们生成的验证码是保存在Tomcat1的session中,而处理这个请求的Tomcat2的session中是没有数据的,这就造成了session共享的数据丢失问题。

为了解决这个问题,我们可以使用Redis来对session的数据进行统一存储管理,这样每一台Tomcat都能获取同一份数据了。

以短信验证码登录为例:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第41张图片

在登录功能中主要存储的信息有两个,一是生成的验证码,二是登录的用户信息,前者需要拿来进行登录校验,后者用来进行拦截操作(部分功能需要登录之后才能使用)。

生成验证码:

@Override
    public Result sendCode(String phone, HttpSession session) {
        //1、校验手机号
        if (RegexUtils.isPhoneInvalid(phone)){
            //2、手机号不符合,返回错误信息
            return Result.fail("手机号格式错误!");
        }
        //3、手机号符合,生成验证码
        String code = RandomUtil.randomNumbers(6);
        //4、保存验证码到redis中 设置验证码有效期为2分钟
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);
        //5、发送验证码
        log.debug("发送短信验证码成功!验证码:{}",code);
        return Result.ok();
    }

这里使用的数据类型是String类型,并且设置了验证码的有效期为2分钟,为防止产生的验证码过多而引起不必要的麻烦。

登录校验:

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1、校验手机号码格式
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)){
            //2、手机号不符合,返回错误信息
            return Result.fail("手机号格式错误!");
        }
        //3、手机号码格式正确,校验验证码 从redis中获取验证码
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
        String code = loginForm.getCode();
        if (code == null || !cacheCode.equals(code)){
            //不一致
            return Result.fail("验证码错误");
        }
        //一致 根据手机号查询用户
        User user = query().eq("phone", phone).one();
        //判断用户是否存在
        if (user == null){
            //不存在 根据电话号码创建用户
            user = createUserWithPhone(phone);
        }
        //保存用户信息到redis中
        //随机生成token,作为登录的令牌
        String token = UUID.randomUUID().toString(true);
        //将User对象转化成Hash存储
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        //这里UserDTO的id为long类型 需要将long类型转换成String类型才能在Redis中存储
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
                CopyOptions
                        .create().setIgnoreNullValue(true)
                        .setFieldValueEditor((fieldName,fieldValue) -> fieldValue.toString()));
        //存储
        stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY+token,userMap);
        //设置有效期
        stringRedisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL,TimeUnit.MINUTES);
        return Result.ok(token);
    }

    private User createUserWithPhone(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX+RandomUtil.randomString(10));
        //保存用户
        save(user);
        return user;
    }

这里我们把用户信息的键设置成一个随机生成的唯一的token,这样可以避免一些敏感信息保存在外

拦截器中从Redis中获取用户信息进行判断拦截:

@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取请求头中的token
        String token = request.getHeader("authorization");
        //判断token是否为空
        if (StrUtil.isBlank(token)){
            response.setStatus(401);
            //拦截
            return false;
        }
        //基于token从redis中获取用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
        //判断用户是否存在
        if (userMap.isEmpty()){
            response.setStatus(401);
            //拦截
            return false;
        }
        //将查询到的hash数据转换成userDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //存在 保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        //刷新token有效时间
        stringRedisTemplate.expire(LOGIN_USER_KEY + token,LOGIN_USER_TTL, TimeUnit.MINUTES);
        //放行
        return true;
    }

这里对拦截器做一些优化,现在我们只有对那些需要拦截的操作才能刷新token的有效期,应该是用户做任何操作都应该刷新token的有效期,我们可以使用两个拦截器,一个用来对所有请求路径进行拦截刷新token的有效期,一个用来对无效的请求进行拦截。

原拦截模式:
从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第42张图片

双拦截模式:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第43张图片

代码:

package com.hmdp.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
import static com.hmdp.utils.RedisConstants.LOGIN_USER_TTL;

/**
 * @program: hm-dianping
 * @Date: 2023/8/8 16:38
 * @Author: Huang
 * @Description:
 */
public class RefreshTokenInterceptor implements HandlerInterceptor {
    private StringRedisTemplate stringRedisTemplate;
    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取请求头中的token
        String token = request.getHeader("authorization");
        //判断token是否为空
        if (StrUtil.isBlank(token)){
            return true;
        }
        //基于token从redis中获取用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
        //判断用户是否存在
        if (userMap.isEmpty()){
            return true;
        }
        //将查询到的hash数据转换成userDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //存在 保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        //刷新token有效时间
        stringRedisTemplate.expire(LOGIN_USER_KEY + token,LOGIN_USER_TTL, TimeUnit.MINUTES);
        //放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //移除用户
        UserHolder.removeUser();
    }
}
package com.hmdp.utils;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @program: hm-dianping
 * @Date: 2023/8/8 16:38
 * @Author: Huang
 * @Description:
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断用户是否存在
        if (UserHolder.getUser() == null){
            response.setStatus(401);
            return false;
        }
        return true;
    }

}

config配置类

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;
import com.hmdp.utils.RefreshTokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * @program: hm-dianping
 * @Date: 2023/8/8 16:46
 * @Author: Huang
 * @Description:
 */
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册拦截器并设置放行路径
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                "/shop/**",
                "/voucher/**",
                "/shop-type/**",
                "/upload/**",
                "/blog/hot",
                "/user/code",
                "/user/login"
        ).order(1);
        //order越小越先执行
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);

    }
}

Redis缓存

redis的读写效率高,在实际场景中能用来做缓存,那么什么是缓存呢?

缓存是数据交换的缓冲区,是存储数据的地方,一般读写性能要求较高。缓存有好的一面也有坏的一面。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第44张图片

redis的数据是存储在内存当中,所以它的读写效率很高,所以常用来做缓存。那么redis在项目中是如何作为缓存的呢?下面以商铺查询为例,介绍redis如何作为缓存在项目中提高项目的效率。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第45张图片

一般情况下,当前端发出一个查询的请求时,我们需要去数据库中查询,在数据库中查询是io操作,这使得查询速率会很慢,这时我们便需要redis作为缓存,当请求打到后端时,我们先从redis缓存中查询我们需要的数据,假如在redis缓存中查询到了我们需要的数据之后,我们可以直接返回,这个过程称为命中,假如redis缓存中没有我们需要的数据,我们则从数据中进行查询,查询到了之后需要将数据写入缓存中以便下一次查询,最后再返回给前端,当下一次发起同样的请求查询同样的数据时,便可以从redis缓存中查询,大大提高查询效率。

package com.hmdp.service.impl;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

import static com.hmdp.utils.RedisConstants.CACHE_SHOP_KEY;

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryShopById(Long id) {
        //1、从redis中读取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2、判断redis中是否有缓存
        if (StrUtil.isNotBlank(shopJson)){
            //3、有,直接读取返回
            return Result.ok(JSONUtil.toBean(shopJson,Shop.class));
        }
        //4、没有 从数据库中读取
        Shop shop = getById(id);
        //5、判断数据库中是否存在
        if (shop == null){
            //6、不存在 返回错误信息
            return Result.fail("商铺不存在!");
        }
        //7、存在 写入缓存
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop));
        return Result.ok(shop);
    }
}

缓存更新策略

redis缓存是存储在内存当中,内存的大小是有限的,比较珍贵,所以我们需要有一个缓存的更新策略来保证缓存不会将内存撑爆。缓存的更新策略有以下三种:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第46张图片

不同的业务场景所使用的更新策略也不同。相对于内存淘汰和超时剔除,主动更新会更安全可靠一些。主动更新策略又有几种不同的方案。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第47张图片

而这三种方案中第一个方案相对于更有优势。在使用方案一时,我们会遇到三个问题。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第48张图片

第三个问题,是先删除缓存还是先操作数据库,下面看具体的分析。

先删缓存再操作数据库:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第49张图片

这种做法的弊端是:如图所示的运行顺序,当线程1删除缓存之后,由于更新数据库所需要花费的时间很长,所以当线程2来查询数据时会先查缓存,缓存中的数据已经被线程1删除了,线程2便会起查询数据库中的数据并且把数据重新写入缓存当中,在此期间,更新数据库的操作还没完成,缓存在被线程1删除之后,又被线程2重新写入一份旧数据,这样就造成了数据不同步的问题,在实际开发过程中,这样的情况挺常见。

先操作数据库,再删除缓存:
从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第50张图片

这种做法同样有弊端:如图所示,当线程1去查询数据,先查询缓存,发现未命中,之后去查询数据库,得到了一份数据,这时线程2进来更新数据库,将数据改变了,并且将缓存删掉了,线程1又将先前查询到旧数据写入缓存中,这时便造成了数据不同步的问题。

这两种方式都会出现数据不同步的问题,但是第二种出现问题的概率要比第一种低,所以推荐使用第二种,先操作数据库再删除内存。

缓存穿透

缓存穿透是指当客户端请求的数据在缓存和数据库中都不存在时,这些请求就都会打到数据库当中对你数据库进行查询,当这类请求数量多的情况下,数据库会顶不住压力从而崩掉。

解决方案:

缓存空对象:当我们发现缓存和数据库中都不存在数据时,我们在缓存中添加一个空对象并设置短暂的TTL值,当下次请求打进来时从缓存中获取空对象返回,大大提高效率。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第51张图片

这方案的缺点就是会产生额外的内存消耗,可能造成短期的不一致(当数据库中添加了新的数据,如果先前保存的空缓存还未过期,请求获取的数据还是空对象,与数据库中的数据不一致,我们可以通过控制空缓存的TTL时间来限制这个问题)

代码:

//缓存穿透
    public Shop queryWithPassThrough(Long id){
        //1、从redis中读取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2、判断redis中是否有缓存
        if (StrUtil.isNotBlank(shopJson)){
            //3、有,直接读取返回
            return JSONUtil.toBean(shopJson,Shop.class);
        }
        //判断缓存中是否有空缓存
        if (shopJson != null){
            return null;
        }
        //4、没有 从数据库中读取
        Shop shop = getById(id);
        //5、判断数据库中是否存在
        if (shop == null){
            //6、不存在 返回错误信息
            //向redis缓存中写入空信息
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //7、存在 写入缓存
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop));
        return shop;
    }

布隆过滤:布隆过滤是在读取缓存之前再加一层过滤器,判断数据是否存在,如果不存在则直接拒绝访问。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第52张图片

缓存雪崩

缓存雪崩是指在某一段时间里大量的缓存同时过期或者Redis直接宕机,导致大量的请求到达数据库,给数据库带来巨大的压力。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第53张图片

解决方案:

  • 给不同的Key添加随机的TTL值,使它们不在同一时刻过期。
  • 利用redis集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存

缓存击穿

缓存击穿也叫热点Key问题,当某个被高并发并且缓存重建业务复杂的key突然失效了,无数的i请求访问会在瞬间给数据库带来巨大的冲击。经常在商铺办活动抢购的情况下出现,这时会有很多的同样的请求打到服务器中,假如这时数据正在更新,缓存中没有数据,则这些大量的请求都会进行数据库。
从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第54张图片

解决方案:

方案一:互斥锁:互斥锁的思路是当线程1查询缓存没有命中后,再去获取互斥锁,加了这把锁之后其他的线程就无法进来操作数据库,只能在外面进行休眠等待,直到线程1完成了数据库的操作并且将数据存入缓存中,在外等着的线程就可以读取缓存返回了。

互斥锁结构图:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第55张图片

代码案例流程图:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第56张图片

代码:

 //互斥锁解决缓存击穿
    public Shop queryWithMutes(Long id){
        Shop shop = null;
        try {
            //1、从redis中读取缓存
            String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //2、判断redis中是否有缓存
            if (StrUtil.isNotBlank(shopJson)){
                //3、有,直接读取返回
                return JSONUtil.toBean(shopJson,Shop.class);
            }
            //判断缓存中是否有空缓存
            if (shopJson != null){
                return null;
            }
            //4、没有 从数据库中读取
            //未命中 尝试获取互斥锁
            if (!tryLock(LOCK_SHOP_KEY+id)){
                //获取失败,说明有其他线程正在操作数据库 等待
                Thread.sleep(50);
                //重新尝试读取缓存 递归
                queryWithMutes(id);//可用循环代替 这里会一直读取redius直到redis中有数据为止
            }
            /*获取锁成功 进行第二次读取缓存 二次读取缓存的原因是:如果当前一个线程刚刚操作完数据库并且释放了锁,后一个线程刚好读取完空缓存然后拿到了锁
            这样就会再一次对数据库进行操作,在高并发的环境下可能有大量的线程出现这种情况,从而我们需要在拿到锁之后再做一次缓存读取,防止上述情况发生
            */
            //1、从redis中读取缓存
            String newShopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //2、判断redis中是否有缓存
            if (StrUtil.isNotBlank(newShopJson)){
                //3、有,直接读取返回
                return JSONUtil.toBean(newShopJson,Shop.class);
            }
            //判断缓存中是否有空缓存
            if (newShopJson != null){
                return null;
            }
            shop = getById(id);
            //5、判断数据库中是否存在
            if (shop == null){
                //6、不存在 返回错误信息
                //向redis缓存中写入空信息
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //7、存在 写入缓存
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            //释放锁
            unLock(LOCK_SHOP_KEY+id);
        }
        return shop;
    }
    
    //加锁
    public boolean tryLock(String id){
        //setIfAbsent方法对应String类型的SETNX key val命令,只有再当前key不存在时才能set成功,可以很好的充当锁的作用
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent(id, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(lock);
    }

    //释放锁
    public void unLock(String id){
        stringRedisTemplate.delete(id);
    }

这里有两个注意点,第一是二次读取缓存,我们在请求刚打入时做了一次缓存读取,读取失败后去获取锁,在获取锁成功之后要进行第二次缓存读取,这样做的原因是:如果当前一个线程刚刚操作完数据库并且释放了锁,后一个线程刚好读取完空缓存然后拿到了锁,这样就会再一次对数据库进行操作,在高并发的环境下可能有大量的线程出现这种情况,从而还是有很多的线程去操作数据库,所以我们需要在拿到锁之后再做一次缓存读取,防止上述情况发生。

第二个注意点是,我们这里用的锁并不是常规的lock锁和synchronized,我们采用的是redis中的SETNX key val命令,只有再当前key不存在时才能set成功,可以很好的充当锁的作用,这就能使所有的线程共用同一把锁,分布式锁的思想,不用lock和synchronized的原因是synchronized和lock是单机锁,每个tomcat服务器都会有锁,每次负载均衡到不同的服务器,就会出现有多把锁的情况。

互斥锁解决缓存击穿问题没有额外的内存消耗,能保证数据的一致性,实现起来比较简单,但是每一条未获取锁的线程都需要等待,性能会受到影响,还有死锁的风险。

方案二:逻辑过期:逻辑过期的思想是在缓存对象中添加一个逻辑过期的属性,当线程1进来时,下读取缓存判断是否过期,如果过期则去获取锁,获取锁成功之后开启一条新的线程去操作数据库,自己则带着已经过期的旧数据直接返回,当其他线程进来获取锁失败直接返回过期信息,这样线程就不会一直等待数据更新,提高性能,

逻辑过期结构图:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第57张图片

案例代码流程图:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第58张图片

代码:

 //逻辑日期解决缓存击穿问题
    private Shop queryWithLogicalExpire(Long id) {
        //1、从redis中读取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2、判断redis中是否有缓存
        if (StrUtil.isBlank(shopJson)){
            //未命中,直接返回空
            return null;
        }
        //命中 将获取的JSON反序列化成对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //判断缓存是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //未过期
            return shop;
        }
        //过期 尝试获取互斥锁
        boolean isLock = tryLock(CACHE_SHOP_KEY + id);
        if (isLock){
            //获取成功 开启线程 定义了一个线程池
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    //释放锁
                    unLock(CACHE_SHOP_KEY + id);
                }
            });
        }
        //获取失败 再次读取缓存
        //1、从redis中读取缓存
        String newShopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2、判断redis中是否有缓存
        if (StrUtil.isBlank(newShopJson)){
            //未命中,直接返回空
            return null;
        }
        RedisData NewRedisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop newShop = JSONUtil.toBean((JSONObject) NewRedisData.getData(), Shop.class);
        return newShop;
    }
    
    public void saveShop2Redis(Long id,Long expireSeconds){
        //查询商店信息
        Shop shop = getById(id);
        //封装过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusMinutes(expireSeconds));
        //写入redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
    }

这里需要注意的是,我们需要在原来的shop添加一个逻辑时间的属性,一般的按照规范来说,我们不能直接去修改原来的对象,降低耦合,我们采用的方案是重新创建一个类RedisData,将Shop类作为RedisDate的一个属性存进去,再在RedisDate中添加一个逻辑时间的属性,这样做可以很好的降低代码的耦合性。

package com.hmdp.utils;
import lombok.Data;
import java.time.LocalDateTime;

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

超卖问题

超卖问题是典型的线程安全问题,顾名思义,超卖问题就是商家需要卖出的一类数量有限的商品时,由于多线程同时进行操作数据库,使得数据库的中的商品数量数据出现负数的情况,具体线程执行流程如下图,假设现在某件商品的库存为1,当线程1去查询数据库中的商品库存是否大于0,之后再去对数据库的库存进行扣减操作,但在这时,线程2和线程3也进来了,并且在线程1对数据库进行库存减扣之前进行了查询库存的操作,这时他们拿到的库存数量也是1,同样也可以执行减扣的操作,这时便出现了商品超卖问题,一件商品有三个人买到。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第59张图片

解决超卖问题的常见方法就是加锁

乐观锁和悲观锁

乐观锁和悲观锁是两种常见的加锁理念,下面看看这这两种锁的区别

悲观锁:悲观锁认为线程安全一定会发生,所以在操作数据之前先获取锁,确保线程串行执行,例如Synchronized、Lock都属于悲观锁。

乐观锁:乐观锁认为线程安全不一定会发生,所以不加锁,只有当更新数据的时候去判断数据有没有被修改,如果没有被修改则认为是安全的,自己才可以跟更新数据,如果被修改了则说明出现了线程安全问题,此时可以重试或异常。

乐观锁的关键是判断得到的数据是否被修改过,常见的方法有两种:

版本号法:我们给每一条数据添加一个version版本字段,每次更新数据的时候对version进行加一更新并且使用where条件限制执行,必须当前的版本号与之前查询所得的版本号相同才能执行更新操作。

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第60张图片

CAS法:CAS法与版本号法思想是一样的,只不过实现方法不同,CAS法没有给数据添加version字段,而是直接使用查出来的额数据作为限制条件,我们在对数据进行更新的时候,先判断当前的数据是否和先前查询得到的数据相同,用查出来的数据代替version的作用。
从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第61张图片

实战运用:

从入门到入土,万字超详细Redis学习笔记 【基础篇】+【实战篇】_第62张图片

代码:

package com.hmdp.service.impl; 
import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;
    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        //1、查询优惠卷
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2、判断秒杀是否开始
        if(voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀尚未开始!");
        }
        //3、判断秒杀是否结束
        if(voucher.getBeginTime().isBefore(LocalDateTime.now())){
            //已经结束
            return Result.fail("秒杀已经结束!");
        }
        //4、判断库存是否充足
        if (voucher.getStock() < 1){
            return Result.fail("库存不足!");
        }
        //5、减扣库存 这里使用了乐观锁的CAS法
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                //.eq("stock",voucher.getStock())//where id = ? and stock = ? //CAS法
                .gt("stock",0)
                .update();
        if (!success){
            //减扣失败
            return Result.fail("库存不足!");
        }
        //6、创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1、订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2、用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setVoucherId(userId);
        //6.3、代金卷id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);
        //7、返回订单id
        return Result.ok(orderId);
    }
}

这里做了优化,原来的方式是当stock等于先前查询的数据才进行删减库存的操作,这样做会导致效率低下的问题,所有我们将等于的条件改成大于0的条件,这样可以很好的提高效率。

分布式锁

未完待续

你可能感兴趣的:(java,学习,redis)