redis笔记

安装

单机安装Redis

# 安装Redis依赖(Redis是基于C语言编写的，因此首先需要安装Redis所需要的gcc依赖：)
yum install -y gcc tcl

下载安装包

挑一个版本下载即可

https://download.redis.io/releases/

# 将下载好的安装包放到/usr/local/src 目录

# 解压
tar -xzf redis-6.2.6.tar.gz

# 进入redis目录
cd redis-6.2.6

# 运行编译命令（如果没有出错，应该就安装成功了）
make && make install

默认的安装路径是在 /usr/local/bin目录下该目录以及默认配置到环境变量，因此可以在任意目录下运行这些命令。

redis-cli：是redis提供的命令行客户端
redis-server：是redis的服务端启动脚本
redis-sentinel：是redis的哨兵启动脚本

启动

默认启动

安装完成后，在任意目录输入redis-server命令即可启动Redis

# 这种启动属于`前台启动`，会阻塞整个会话窗口，窗口关闭或者按下`CTRL + C`则Redis停止。不推荐使用。
redis-server

指定配置启动

如果要让Redis以后台方式启动，则必须修改Redis配置文件，就在之前解压的redis安装包下（/usr/local/src/redis-6.2.6），名字叫redis.conf

# 备份配置文件
cp redis.conf redis.conf.bck

# 修改redis.conf文件中的一些配置
# 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行
daemonize yes 
# 密码，设置后访问Redis必须输入密码
requirepass 123321

Redis的其它常见配置：

# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"

启动Redis

# 进入redis安装目录 
cd /usr/local/src/redis-6.2.6
# 启动
redis-server redis.conf

停止服务

# 利用redis-cli来执行 shutdown 命令，即可停止 Redis 服务，
# 因为之前配置了密码，因此需要通过 -u 来指定密码
redis-cli -u 123321 shutdown

开机自启

通过配置来实现开机自启

# 新建一个系统服务文件
vi /etc/systemd/system/redis.service

内容如下:

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

重载系统服务:

systemctl daemon-reload

现在，我们可以用下面这组命令来操作redis了

# 启动
systemctl start redis
# 停止
systemctl stop redis
# 重启
systemctl restart redis
# 查看状态
systemctl status redis

执行下面的命令，可以让redis开机自启

systemctl enable redis

常见命令

通用命令

# 可以查看一个命令的具体用法
help [command]

# 查看符合模板的所有key
KEYS

# 删除一个指定的key
DEL

# 判断key是否存在
EXISTS

# 给一个key设置有效期，有效期到期时该key会被自动删除
EXPIRE

# 查看一个KEY的剩余有效期
TTL

String

String的常见命令

# 添加或者修改已经存在的一个String类型的键值对
# 如果在后面加上nx，则作用域SETNX一样
# 如果在后面加ex，则与SETEX的效果一样
SET

# 根据key获取String类型的value
GET

# 批量添加多个String类型的键值对
MSET

# 根据多个key获取多个String类型的value
MGET

# 让一个整型的key自增1
INCR

# 让一个整形key自减(和上面的反过来)
DECR

# 让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2
INCRBY

# 让一个整型的key自减并指定步长，例如：decrby num 2 让num值自减2(和上面的反过来)
DECRBY

# 让一个浮点类型的数字自增并指定步长
INCRBYFLOAT

# 让一个浮点类型的数字自减并指定步长
DERCBYFLOAT

# 添加一个String类型的键值对，前提是这个key不存在，否则不执行
SETNX

# 添加一个String类型的键值对，并且指定有效期
SETEX

Key结构

Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开

# 例子格式（只要是用：隔开就行，不管你怎么定义格式）
# 1.项目名:业务名:类型:id

# 2.user相关的key和value(注意：值需要用引号包住（这里复制的话需要自己加引号）)
bzl:user:1

{"id":1,  "name": "Jack", "age": 21}

# 3.product相关的key和value
bzl:product:1

{"id":1,  "name": "小米11", "price": 4999}

理解视图

Hash

常见命令

# 添加或者修改hash类型key的field的值
HSET

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

# 批量添加多个hash类型key的field的值
HMSET

# 批量获取多个hash类型key的field的值
HMGET

# 获取一个hash类型的key中的所有的field和value
HGETALL

# 获取一个hash类型的key中的所有的field
HKEYS

# 让一个hash类型key的字段值自增并指定步长
HINCRBY

# 添加一个hash类型的key的field值，前提是这个field不存在，否则不执行
HSETNX

理解视图

List

特点

可以看做是一个双向链表结构

有序
元素可以重复
插入和删除快
查询速度一般

常见命令

# 向列表左侧插入一个或多个元素
LPUSH

# 移除并返回列表左侧的第一个元素，没有则返回nil
LPOP

#向列表右侧插入一个或多个元素
RPUSH

# 移除并返回列表右侧的第一个元素
RPOP

# 返回一段角标范围内的所有元素
LRANGE

# 与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
BLPOP和BRPOP

Set

特点

无序
元素不可重复
查找快
支持交集、并集、差集等功能

常见命令

# 向set中添加一个或多个元素
SADD

# 移除set中的指定元素
SREM

# 返回set中元素的个数
SCARD

# 判断一个元素是否存在于set中
SISMEMBER

# 获取set中的所有元素
SMEMBERS

# 求key1与key2的交集
SINTER

# 求key1与key2的差集
SDIFF

SortedSet

常见命令

# 添加一个或多个元素到sorted set ，如果已经存在则更新其score值
ZADD

# 删除sorted set中的一个指定元素
ZREM

# 获取sorted set中的指定元素的score值
ZSCORE

# 获取sorted set 中的指定元素的排名
ZRANK

# 获取sorted set中的元素个数
ZCARD

# 统计score值在给定范围内的所有元素的个数
ZCOUNT

# 让sorted set中的指定元素自增，步长为指定的increment值
ZINCRBY

# 按照score排序后，获取指定排名范围内的元素
ZRANGE

# 按照score排序后，获取指定score范围内的元素
ZRANGEBYSCORE

# 求差集、交集、并集
ZDIFF、ZINTER、ZUNION

注意

所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，例如：

升序获取sorted set 中的指定元素的排名：ZRANK key member
降序获取sorted set 中的指定元素的排名：ZREVRANK key memeber

redis的java客户端

官网

打开redis官网

启动（到redis安装目录下执行）

# 启动服务（后面可以加上配置文件（.conf的那个文件））
redis-server.exe

# cmd客户端
redis-cli.exe

# 桌面管理端（二选一即可，选第一个吧，这个还在更新，第二个最后更新是在22年）
# AnotherRedisDesktopManager（下载地址）
https://github.com/qishibo/AnotherRedisDesktopManager/releases

# RedisDesktopManager（下载地址）
https://github.com/lework/RedisDesktopManager-Windows

密码

# 客户端中设置密码
config set requirepass test123

# 客户端中查看密码
config get requirepass

三个常用客户端的说明

Jedis

官网

打开jedis官网

依赖

xml

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>3.7.0</version>
</dependency>

直接使用

java

// 建立连接
Jedis jedis = new Jedis("192.168.111.128", 6379);
// 设置密码
jedis.auth("123321");
// 选择库
jedis.select(0);

使用方法

使用Jedis，方法名与Redis命令一致

使用例子

java

//插入数据，方法名称就是redis命令，非常简单
String result = edis.set("name", "张三");
System.out.println("result = " + result);
// 获取数据
String name = edis.get("name");
System.out.println("name = " + name);

释放资源

java

// 释放资源
if(jedis != null)
	jedis.close();

Jedis连接池方式使用

使用方式：做一个工具类

java

public class JedisConnectionFacotry {

     private static final JedisPool jedisPool;

     static {
         // 配置连接池
         JedisPoolConfig poolConfig = new JedisPoolConfig();
         // 最大链接
         poolConfig.setMaxTotal(8);
         // 最大空闲链接
         poolConfig.setMaxIdle(8);
         // 最小空闲链接
         poolConfig.setMinIdle(0);
         // 设置最长等待时间，ms
         poolConfig.setMaxWaitMillis(1000);
         // 创建连接池对象
         jedisPool = new JedisPool(poolConfig,
                 "192.168.111.128",6379,1000,"123321");
     }

     public static Jedis getJedis(){
          return jedisPool.getResource();
     }
}

使用

java

    @BeforeEach  
    void setUp(){  
        //建立连接  
        /*jedis = new Jedis("127.0.0.1",6379);*/  
        jedis = JedisConnectionFacotry.getJedis();  
         //选择库  
        jedis.select(0);  
    }  
  
   @AfterEach  
    void tearDown() {  
        if (jedis != null) {  
            jedis.close();  
        }  
    }

注意事项

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

SpringDataRedis

该技术整合了jedis和lettuce，但是spring默认引用了lettuce，如果要用jedis需要自己引入打开SpringDataRedis官网

依赖

xml

<dependencies>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--Jackson依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

打包插件

xml

<build>
    <plugins>
            <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

配置文件

yaml

spring:
  redis:
    host: 192.168.150.101
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8   #最大空闲连接
        min-idle: 0   #最小空闲连接
        max-wait: 100ms #连接等待时间

测试代码

java

@SpringBootTest
class RedisDemoApplicationTests {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "虎哥");
        // 获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

使用方式

stringRedisTemplate（常用）

依赖注入

java

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

序列化方式

默认key和value序列化为字符串

需要在存储前自己进行序列化，以及读取后自己进行反序列化（工具：jackson、fastjson、objectmapper）

使用方式

例子1

java

private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testSaveUser() throws JsonProcessingException {
        // 创建对象
        User user = new User("冰泽兰", 24);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入数据
        stringRedisTemplate.opsForValue().set("user:200", json);

        // 获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
        // 手动反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user1 = " + user1);
    }

存入redis的结果

例子2

java

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @Test
    void testHash() {
        stringRedisTemplate.opsForHash().put("user:400", "name", "虎哥");
        stringRedisTemplate.opsForHash().put("user:400", "age", "21");

        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries = " + entries);
    }
}

结果

redisTemplate（很少用）

使用方式

依赖注入

java

    @Autowired
    private RedisTemplate redisTemplate;

根据需要调用对应方法

序列化方式

注意

如果不设置序列化方式，则存进redis之后会自动转化为下面这样的格式，不仅占空间，而且可读性差 "\xe5\x86\xb0\xe6\xb3\xbd\xe5\x85\xb0"

自定义RedisTemplate的序列化方式

redis序列化接口：RedisSerializer<T>

text

1.StringRedisSerializer
使用场景：key或者hashkey都为字符串的情况下就可以使用
使用方式：RedisSerializer.string()会返回一个StringRedisSerializer，并且会设置编码为UTF-8

java

static RedisSerializer<String> string(){
	return SrtingRediserializer.UTF_8;
}

text

2.GenericJackson2JsonRedisSerializer
使用场景：如果value可能为对象，就可以使用

写一个redis的配置类 配置bean

java

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = 
            							new GenericJackson2JsonRedisSerializer();
        // 设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回
        return template;
    }
}

可能犯的错误

java.lang.ClassNotFoundException: com.fasterxml.jackson.core.JsonProcessingException 解决方式：引入jackson-databind的依赖

缺点

会多生成一个字段（该字段用于反序列化），占用控件较多存入redis的结果：

黑马点评项目知识

短信验证码的登录注册功能

基于session的短信登录

手机号为key，验证码为value

集群下的session共享问题

多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题

Redis实现共享session

Redis实现session的刷新问题

登录的用户访问任何界面都要刷新session

拦截器1——拦截所有路径

不交给spring管理，由我们自己new
preHandle：判断用户是否登录，登录的话会将用户信息存到ThreadLocal中，后面的操作如果需要用户信息可以从ThreadLocal中取（而不是存session），用户的所有访问都会刷新token，没登录直接放行，交给下一个拦截器处理
完成所有操作后将线程将会被回收，所以需要将线程中的ThreadLocal清空，防止内存泄漏等问题

java

public class ReFreshTokenInterceptor implements HandlerInterceptor {  
    //由于这个类不是由spring构建，而是由我们自己new出来的，所以不能使用依赖注入，  
    // 所以我们需要自己在构造的时候注入（注入方式看拦截器（拦截器是交给spring管理的，所以可以直接用依赖注入和传参的方式解决）  
    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");  
        if (StrUtil.isBlank(token)) {  
            return true;  
        }  
        //基于token获取redis中的用户  
        String key = LOGIN_USER_KEY + token;  
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);  
  
        if (userMap.isEmpty()) {  
            return true;  
        }  
        //将查询到的hash数据转化为userDTO对象  
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);  
        //存在将用户信息保存到ThreadLocal中  
        UserHolder.saveUser(userDTO);  
        //刷新token  
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.SECONDS);  
        //放行  
        return true;  
    }  
  
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {  
        UserHolder.removeUser();  
    }  
}

java

public class UserHolder {  
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();  
  
    public static void saveUser(UserDTO user){  
        tl.set(user);  
    }  
  
    public static UserDTO getUser(){  
        return tl.get();  
    }  
  
    public static void removeUser(){  
        tl.remove();  
    }  
}

java

import lombok.Data;  
  
@Data  
public class UserDTO {  
    private Long id;  
    private String nickName;  
    private String icon;  
}

拦截器2——拦截需要登录的路径

如果用户没登录，直接响应401

商家查询的缓存功能

什么是缓存

缓存时一种具备高效读写能力的数据暂存区域作用：

降低后端负载
提高服务读写响应速度成本：
开发成本
运维成本
一致性问题

添加redis缓存

缓存更新策略

三种策略

txt

内存淘汰：Redis自带的内存淘汰机制

过期淘汰：利用expire命令给数据设置过期时间

主动更新：主动完成数据库与缓存的同时更新

策略选择

低一致性需求

内存淘汰或过期淘汰

高一致性需求

主动更新为主
过期淘汰兜底

主动更新的方案

Cache Aside：缓存调用者在更新数据库的同时完成对缓存的更新

一致性良好
实现难度一般

Read/Write Through：缓存与数据库集成为一个服务，服务保证两者的一致性，对外暴露API接口。调用者调用API，无需知道自己操作的是数据库还是缓存，不关心一致性。

一致性优秀
实现复杂
性能一般

Write Back：缓存调用者的CRUD都针对缓存完成。由独立线程异步的将缓存数据写到数据库，实现最终一致

一致性差
性能好
实现复杂

Cache Aside的模式选择

text

更新缓存还是删除缓存？
更新缓存会产生无效更新，并且存在较大的线程安全问题  x
删除缓存本质是延迟更新，没有无效更新，线程安全问题相对较低  √

先操作数据库还是缓存？
先更新数据，再删除缓存===>在满足原子性的情况下，安全问题概率较低
先删除缓存，再更新数据库===>安全问题概率较高

如何确保数据库与缓存操作原子性？
单体系统===>利用事务机制
分布式系统===>利用分布式事务机制

最佳实践

查询数据时

先查询缓存
如果缓存命中，直接返回
如果缓存未命中，则查询数据库
将数据库数据写入缓存
返回结果

修改数据库时

先修改数据库
然后删除缓存确保两者的原子性

缓存穿透

产生原因

客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库

解决方案

缓存空对象

思路：对于不存在的数据也在Redis建立缓存，值为空，并设置一个较短的TTL时间
优点：实现简单，维护方便
缺点：额外的内存消耗；短期的数据不一致问题

布隆过滤

思路：利用布隆过滤算法，在请求进入Redis之前先判断是否存在，如果不存在则直接拒绝请求
优点：内存占用少
缺点：实现复杂；存在误判的可能性

其它

做好数据的基础格式校验
加强用户权限校验
做好热点参数的限流

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

常见的解决方案有：

给不同的Key的TTL添加随机值，这样KEY的过期时间不同，不会大量KEY同时过期
利用Redis集群提高服务的可用性，避免缓存服务宕机
给缓存业务添加降级限流策略
给业务添加多级缓存，比如先查询本地缓存，本地缓存未命中再查询Redis，Redis未命中再查询数据库。即便Redis宕机，也还有本地缓存可以抗压力

缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

由于我们采用的是Cache Aside模式，当缓存失效时需要下次查询时才会更新缓存。当某个key缓存失效时，如果这个key是热点key，并发访问量比较高。就会在一瞬间涌入大量请求，都发现缓存未命中，于是都会去查询数据库，尝试重建缓存。可能一瞬间就把数据库压垮了。如上图所示：

线程1发现缓存未命中，准备查询数据库，重建缓存，但是因为数据比较复杂，导致查询数据库耗时较久
在这个过程中，一下次来了3个新的线程，就都会发现缓存未命中，都去查询数据库
数据库压力激增

常见的解决方案有两种：

互斥锁：给重建缓存逻辑加锁，避免多线程同时指向
逻辑过期：热点key不要设置过期时间，在活动结束后手动删除。

面试总结

如何保证缓存的双写一致性？

缓存的双写一致性很难保证强一致，只能尽可能降低不一致的概率，确保最终一致。我们项目中采用的是Cache Aside模式。简单来说，就是在更新数据库之后删除缓存；在查询时先查询缓存，如果未命中则查询数据库并写入缓存。同时我们会给缓存设置过期时间作为兜底方案，如果真的出现了不一致的情况，也可以通过缓存过期来保证最终一致。

为什么不采用延迟双删机制？延迟双删的第一次删除并没有实际意义，第二次采用延迟删除主要是解决数据库主从同步的延迟问题，我认为这是数据库主从的一致性问题，与缓存同步无关。既然主节点数据已经更新，Redis的缓存理应更新。而且延迟双删会增加缓存业务复杂度，也没能完全避免缓存一致性问题，投入回报比太低。

如何解决缓存穿透问题

缓存穿透也可以说是穿透攻击，具体来说是因为请求访问到了数据库不存在的值，这样缓存无法命中，必然访问数据库。如果高并发的访问这样的接口，会给数据库带来巨大压力。

我们项目中都是基于布隆过滤器来解决缓存穿透问题的，当缓存未命中时基于布隆过滤器判断数据是否存在。如果不存在则不去访问数据库。

当然，也可以使用缓存空值的方式解决，不过这种方案比较浪费内存。

如何解决缓存雪崩问题

缓存雪崩的常见原因有两个，第一是因为大量key同时过期。针对问这个题我们可以可以给缓存key设置不同的TTL值，避免key同时过期。

第二个原因是Redis宕机导致缓存不可用。针对这个问题我们可以利用集群提高Redis的可用性。也可以添加多级缓存，当Redis宕机时还有本地缓存可用。

如何解决缓存击穿问题

缓存击穿往往是由热点Key引起的，当热点Key过期时，大量请求涌入同时查询，发现缓存未命中都会去访问数据库，导致数据库压力激增。解决这个问题的主要思路就是避免多线程并发去重建缓存，因此方案有两种。

第一种是基于互斥锁，当发现缓存未命中时需要先获取互斥锁，再重建缓存，缓存重建完成释放锁。这样就可以保证缓存重建同一时刻只会有一个线程执行。不过这种做法会导致缓存重建时性能下降严重。

第二种是基于逻辑过期，也就是不给热点Key设置过期时间，而是给数据添加一个过期时间的字段。这样热点Key就不会过期，缓存中永远有数据。

查询到数据时基于其中的过期时间判断key是否过期，如果过期开启独立新线程异步的重建缓存，而查询请求先返回旧数据即可。当然，这个过程也要加互斥锁，但由于重建缓存是异步的，而且获取锁失败也无需等待，而是返回旧数据，这样性能几乎不受影响。

需要注意的是，无论是采用哪种方式，在获取互斥锁后一定要再次判断缓存是否命中，做dubbo check. 因为当你获取锁成功时，可能是在你之前有其它线程已经重建缓存了。

redis笔记 ​

安装 ​

单机安装Redis ​

下载安装包 ​

启动 ​

默认启动 ​

指定配置启动 ​

Redis的其它常见配置： ​

启动Redis ​

停止服务 ​

开机自启 ​

常见命令 ​

通用命令 ​

String ​

String的常见命令 ​

Key结构 ​

Hash ​

常见命令 ​

List ​

特点 ​

常见命令 ​

Set ​

特点 ​

常见命令 ​

SortedSet ​

常见命令 ​

redis的java客户端 ​

官网 ​

启动（到redis安装目录下执行） ​

密码 ​

三个常用客户端的说明 ​

Jedis ​

官网 ​

依赖 ​

直接使用 ​

使用方法 ​

使用例子 ​

释放资源 ​

Jedis连接池方式使用 ​

使用方式：做一个工具类 ​

SpringDataRedis ​

依赖 ​

配置文件 ​

测试代码 ​

使用方式 ​

stringRedisTemplate（常用） ​

依赖注入 ​

序列化方式 ​

使用方式 ​

例子1 ​

例子2 ​

redisTemplate（很少用） ​

使用方式 ​

依赖注入 ​

根据需要调用对应方法 ​

序列化方式 ​

自定义RedisTemplate的序列化方式 ​

缺点 ​

黑马点评项目知识 ​

短信验证码的登录注册功能 ​

基于session的短信登录 ​

集群下的session共享问题 ​

Redis实现共享session ​

Redis实现session的刷新问题 ​

拦截器1——拦截所有路径 ​

拦截器2——拦截需要登录的路径 ​

商家查询的缓存功能 ​

什么是缓存 ​

添加redis缓存 ​

缓存更新策略 ​

三种策略 ​

策略选择 ​

主动更新的方案 ​

Cache Aside的模式选择 ​

最佳实践 ​

查询数据时 ​

修改数据库时 ​

缓存穿透 ​

产生原因 ​

解决方案 ​

redis笔记

安装

单机安装Redis

下载安装包

启动

默认启动

指定配置启动

Redis的其它常见配置：

启动Redis

停止服务

开机自启

常见命令

通用命令

String

String的常见命令

Key结构

Hash

常见命令

List

特点

常见命令

Set

特点

常见命令

SortedSet

常见命令

redis的java客户端

官网

启动（到redis安装目录下执行）

密码

三个常用客户端的说明

Jedis

官网

依赖

直接使用

使用方法

使用例子

释放资源

Jedis连接池方式使用

使用方式：做一个工具类

SpringDataRedis

依赖

配置文件

测试代码

使用方式

stringRedisTemplate（常用）

依赖注入

序列化方式

使用方式

例子1

例子2

redisTemplate（很少用）

使用方式

依赖注入

根据需要调用对应方法

序列化方式

自定义RedisTemplate的序列化方式

缺点

黑马点评项目知识

短信验证码的登录注册功能

基于session的短信登录

集群下的session共享问题

Redis实现共享session

Redis实现session的刷新问题

拦截器1——拦截所有路径

拦截器2——拦截需要登录的路径

商家查询的缓存功能

什么是缓存

添加redis缓存

缓存更新策略

三种策略

策略选择

主动更新的方案

Cache Aside的模式选择

最佳实践

查询数据时

修改数据库时

缓存穿透

产生原因

解决方案