redis的高级应用

阿杰么

已于 2022-12-10 19:11:31 修改

阅读量414

点赞数

分类专栏：一起学Java 文章标签： redis

于 2022-11-23 20:26:53 首次发布

本文链接：https://blog.csdn.net/m0_55916987/article/details/128007150

版权

一起学Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

五、Java应⽤连接Redis

5.1 设置redis允许远程连接

Java应⽤连接Redis，⾸先要将我们的Redis设置允许远程连接

修改redis-6379.conf

## 关闭保护模式
protected-mode no
## 将bind注释掉（如果不注释，默认为 bind 127.0.0.1 只能本机访问）
# bind 127.0.0.1
## 密码可以设置（也可以不设置）
# requirepass 123456

重启redis
```
redis-server redis-6379.conf
```
在宝塔面板放行 6379端口

5.1 在普通Maven⼯程连接Redis

使⽤jedis客户端连接

5.1.1 添加Jedis依赖

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

5.1.2 使⽤案例

public static void main(String[] args) {
     Product product = new Product("101", "aaaa", 2.5);
     //1.连接redis
     Jedis jedis = new Jedis("ajie.jimo.fun", 6379);
     //2.操作
     String s = jedis.set(product.getProductId(), new
     Gson().toJson(product));
     System.out.println(s);
     //3.关闭连接
     jedis.close();
}

5.1.3 redis远程可视化客户端

Redis desktop manager

5.2 在SpringBoot⼯程连接Redis

Spring Data Redis依赖中，提供了⽤于连接redis的客户端：

RedisTemplate
StringRedisTemplate

5.2.1 创建springBoot应⽤

5.2.2 配置redis

application.yml⽂件配置redis的连接信息

spring:
  redis:
    host: ajie.jimo.fun
    port: 6379
    database: 0
    password: 8023zsj

5.2.3 使⽤redis客户端连接redis

直接在service中注⼊ RedisTemplate 或者 StringRedisTemplate ,就可以使⽤此对象完成redis操作

5.3 Spring Data Redis

5.3.1 不同数据结构的添加操作

//1.string
//添加数据 set key value
stringRedisTemplate.boundValueOps(product.getProductId()).set(jsonstr);
//2.hash
stringRedisTemplate.boundHashOps("products").put(product.getProductId(),jsonstr);
//3.list
stringRedisTemplate.boundListOps("list").leftPush("ccc");
//4.set
stringRedisTemplate.boundSetOps("s1").add("v2");
//5.zset
stringRedisTemplate.boundZSetOps("z1").add("v1",1.2);

5.3.2 string类型的操作⽅法

//添加数据 set key value
stringRedisTemplate.boundValueOps(product.getProductId()).set(
jsonstr);
//添加数据时指定过期时间 setex key 300 value
stringRedisTemplate.boundValueOps("103").set(jsonstr,300);
//设置指定key的过期时间 expire key 20
stringRedisTemplate.boundValueOps("103").expire(20, TimeUnit.SECONDS);
//添加数据 setnx key value
Boolean absent =stringRedisTemplate.boundValueOps("103").setIfAbsent(jsonstr);

5.3.3 不同数据类型的取值操作

//string
String o = stringRedisTemplate.boundValueOps("103").get();
//hash 
Object v = stringRedisTemplate.boundHashOps("products").get("101");
//list
String s1 = stringRedisTemplate.boundListOps("list").leftPop();
String s2 = stringRedisTemplate.boundListOps("list").rightPop();
String s3 = stringRedisTemplate.boundListOps("list").index(1);
//set
Set<String> vs = stringRedisTemplate.boundSetOps("s1").members();
//zset
Set<String> vs2 = stringRedisTemplate.boundZSetOps("z1").range(0, 5);

六、使⽤redis缓存数据库数据

6.1 redis作为缓存的使⽤流程

6.2 在使⽤redis缓存商品详情(锋迷商城)

6.2.1 在service⼦⼯程添加Spring data redis依赖

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

6.2.2 在application.yml配置redis数据源

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
	 ## 如果后端项⽬服务器和数据库服务器不在同⼀台主机，则需要修改localhost为数据库服务器ip地址
 	  url: jdbc:mysql://localhost:3306/fmmall?characterEncoding=utf-8
      username: root
      password: admin123
  redis:
    port: 6379
    host: 47.96.11.185
    database: 0
    password: 123456

6.3.3 在ProductServiceImpl中修改业务代码

七、使用Redis做缓存使用存在的问题

使用redis作为缓存在高并发场景下有可能出现缓存击穿，缓存穿透，缓存雪崩

7.1 缓存击穿

大量的并发访问同时访问同一个redis中不存在的数据，就会导致大量请求绕过redis同时并访问数据库，对数据库造成高并发的压力

使用双重检测锁解决缓存击穿

  private ObjectMapper objectMapper = new ObjectMapper();

private Logger logger = LoggerFactory.getLogger(IndexImgServiceImpl.class);

@Override
public ResultVO listIndexImgs() {

    //双重检测锁 防止缓存击穿
    List<IndexImg> indexImgs = null;
    try {
        //string 结构缓存轮播图信息
        String imgsStr = stringRedisTemplate.boundValueOps("indexImgs").get();
        if (imgsStr != null) {
            //如果redis中有轮播图信息
            JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, IndexImg.class);
            indexImgs = objectMapper.readValue(imgsStr, javaType);
        } else {
            //1000个请求都会进入else   (service在 Spring 容器中是单例的  会共用一个service实例)
            synchronized (this) {
                //第二次查询redis
                String s = stringRedisTemplate.boundValueOps("indexImgs").get();
                if (s == null) {
                    //只有第一次请求redis s 才为空
                    //如果redis没中有轮播图信息 从数据库查询
                    indexImgs = indexImgMapper.listIndexImgs();
                    logger.info("查询数据库");
                        //存入redis
                     stringRedisTemplate.boundValueOps("indexImgs").set(objectMapper.writeValueAsString(indexImgs));
                        //设置过期时间
                     stringRedisTemplate.boundValueOps("indexImgs").expire(1, TimeUnit.DAYS); 
                } else {
                    JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, IndexImg.class);
                    indexImgs = objectMapper.readValue(s, javaType);
                }
            }
        }
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    //返回数据
    if (indexImgs == null) {
        return new ResultVO(ResStatus.NO, "fail", null);
    } else {
        return new ResultVO(ResStatus.OK, "success", indexImgs);
    }
}

7.2 缓存穿透

大量请求一个数据库不存在的数据，首先在redsi中无法查询，最终所有的请求都会访问数据库，同样会导致数据库承担巨大的访问压力。

解决⽅案：当从数据库查询到⼀个null时，写⼀个⾮空的数据到redis，并设置过期时间

7.3 缓存雪崩

缓存雪崩：缓存大量的数据集中过期，导致请求这些数据的大量并发请求同属访问数据库

解决方案：

将缓存中的数据设置成不同的过期时间
在访问洪峰到达前缓存热点，过期时间设置成流量最低的时段

7.4 Jmeter测试

Jmeter是基于Java开发的⼀个测试⼯具，因此需要先安装JDK

7.4.1 创建测试计划

7.4.2 创建线程组

7.4.3 设置HTTP请求

⼋、Redis⾼级应⽤

使⽤redis作为缓存数据库使⽤⽬的是为了提升数据加载速度、降低对数据库的访问压⼒，我们需要保证redis的可⽤性。

主从配置
哨兵模式
集群配置

8.1 主从配置

主从配置：在多个redis实例建⽴起主从关系，当主redis 中的数据发⽣变化，从redis中的数据也会同步变化。

通过主从配置可以实现redis数据的备份（从redis 就是对主redis 的备份），保证数据的安全性；
通过主从配置可以实现redis的读写分离

主从配置示例

## 在redis-5.0.5⽬录下创建 msconf ⽂件夹
mkdir msconf
## 拷⻉redis.conf⽂件 到 msconf⽂件夹 ---> redis-master.conf
cat redis.conf | grep -v "#" | grep -v "^$" > msconf/redis-master.conf
## 修改 redis-master.conf 端⼝及远程访问设置
vim redis-master.conf

## 将 redis-master.conf 拷⻉两份分别为：redis-slave1.conf redisslave2.conf
sed 's/6380/6381/g' redis-master.conf > redisslave1.conf
sed 's/6380/6382/g' redis-master.conf > redisslave2.conf
## 修改redis-slave1.conf redis-slave2.conf，设置“跟从”---127.0.0.1 6380
vim redis-slave1.conf
vim redis-slave2.conf

## 启动三个redis实例
redis-server redis-master.conf &
redis-server redis-slave1.conf &
redis-server redis-slave2.conf &

8.2 哨兵模式

哨兵模式：⽤于监听主库，当确认主库宕机之后，从备库(从库)中选举⼀个转备为主

哨兵模式配置

##⾸先实现三个redis实例之间的主从配置（如上）
## 创建并启动三个哨兵
## 拷⻉sentinel.conf⽂件三份：sentinel-26380.conf sentinel-26382.conf 
sentinel-26382.conf
## 创建sentinelconf⽬录
mkdir sentinelconf
## 拷⻉sentinel.conf⽂件到 sentinelconf⽬录：sentinel-26380.conf
cat sentinel.conf | grep -v "#" | grep -v "^$" > sentinelconf/sentinel-26380.conf
cd sentinelconf/
vim sentinel-26380.conf

port 26380
daemonize no
pidfile "/var/run/redis-sentinel-26380.pid"
logfile ""
dir "/tmp"
sentinel deny-scripts-reconfig yes
# 此处配置默认的主库的ip 和端⼝ 最后的数字是哨兵数量的⼀半多⼀个
sentinel monitor mymaster 127.0.0.1 6380 2
sentinel config-epoch mymaster 1
sentinel leader-epoch mymaster 1
protected-mode no

sed 's/26380/26381/g' sentinel-26380.conf > sentinel-26381.conf
sed 's/26380/26382/g' sentinel-26380.conf > sentinel-26382.conf

8.3 集群配置

**⾼可⽤：**保证redis⼀直处于可⽤状态，即时出现了故障也有备⽤⽅案保证可⽤性

**⾼并发：**⼀个redis实例已经可以⽀持多达11w并发读操作或者8.1w并发写操作；但是如果对于有更⾼并发需求的应⽤来说，我们可以通过读写分离、集群配置来解决⾼并发问题

Redis集群

Redis集群中每个节点是对等的，⽆中⼼结构
数据按照slots分布式存储在不同的redis节点上，节点中的数据可共享，可以动态调整数据的分布
可扩展性强，可以动态增删节点，最多可扩展⾄1000+节点
集群每个节点通过主备（哨兵模式）可以保证其⾼可⽤性

8.3.1 集群搭建

[root@theo ~]# cd /usr/local/redis-5.0.5
[root@theo redis-5.0.5]# mkdir cluster-conf
[root@theo redis-5.0.5]# cat redis.conf | grep -v "#"|grep -v "^$" >
cluster-conf/redis-7001.conf
[root@theo redis-5.0.5]# cd cluster-conf/
[root@theo cluster-conf]# ls
redis-7001.conf
[root@theo cluster-conf]# vim redis-7001.conf

拷⻉6个⽂件，端⼝分别为 7001-7006

[root@theo cluster-conf]# sed 's/7001/7002/g' redis-7001.conf > redis-7002.conf
[root@theo cluster-conf]# sed 's/7001/7003/g' redis-7001.conf > redis-7003.conf
[root@theo cluster-conf]# sed 's/7001/7004/g' redis-7001.conf > redis-7004.conf
[root@theo cluster-conf]# sed 's/7001/7005/g' redis-7001.conf > redis-7005.conf
[root@theo cluster-conf]# sed 's/7001/7006/g' redis-7001.conf > redis-7006.conf

启动6个redis实例

[root@theo cluster-conf]# redis-server redis-7001.conf &
[root@theo cluster-conf]# redis-server redis-7002.conf &
[root@theo cluster-conf]# redis-server redis-7003.conf &
[root@theo cluster-conf]# redis-server redis-7004.conf &
[root@theo cluster-conf]# redis-server redis-7005.conf &
[root@theo cluster-conf]# redis-server redis-7006.conf &

查看6个实例是否启动
```
ps -ef|grep redis
```

启动集群

 redis-cli --cluster create 47.96.11.185:700147.96.11.185:7002 47.96.11.185:7003 47.96.11.185:7004 47.96.11.185:700547.96.11.185:7006 --cluster-replicas 1

连接集群：
```
 redis-cli -p 7001 -c
```

8.3.2 集群管理

如果集群启动失败：等待节点加⼊（出现很多点点点）
- 云服务器检查安全组是否放⾏redis实例端⼝，以及+10000的端⼝
- Linux防⽕墙是否放⾏redis服务（关闭防⽕墙）
- Linux状态（top）---- 更换云主机操作系统
- redis配置⽂件错误

创建集群：

edis-cli --cluster create
47.96.11.185:7001 47.96.11.185:7002 47.96.11.185:7003
47.96.11.185:7004 47.96.11.185:7005 47.96.11.185:7006 --clusterreplicas 1

查看集群状态

 redis-cli --cluster info 47.96.11.185:7001

平衡节点的数据槽数

 redis-cli --cluster rebalance47.96.11.185:7001

迁移节点槽

删除节点

[root@theo cluster-conf]# redis-cli --cluster del-node
47.96.11.185:7001 4678478aa66b6d37b23944cf7db0ac07298538a4
>>> Removing node 4678478aa66b6d37b23944cf7db0ac07298538a4 from
cluster 47.96.11.185:7001
>>> Sending CLUSTER FORGET messages to the cluster...
>>> SHUTDOWN the node.
[root@theo cluster-conf]# redis-cli --cluster info 47.96.11.185:7002
47.96.11.185:7002 (e26eaf2a...) -> 1 keys | 8192 slots | 2 slaves.
47.96.11.185:7003 (5752eb20...) -> 2 keys | 8192 slots | 1 slaves.
[OK] 3 keys in 2 masters.
0.00 keys per slot on average.

添加节点

 redis-cli --cluster add-node 47.96.11.185:7007 47.96.11.185:7002

8.3.3 SpringBoot应⽤连接集群

添加依赖

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

配置集群节点

spring:
  redis:
    cluster:
      nodes: 47.96.11.185:7001,47.96.11.185:7002,47.96.11.185:7003
      max-redirects: 3

操作集群

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RedisDemo3Application.class)
class RedisDemo3ApplicationTests {
 @Autowired
 private StringRedisTemplate stringRedisTemplate;
 @Test
 void contextLoads() {
 //stringRedisTemplate.boundValueOps("key1").set("value1");
 String s = stringRedisTemplate.boundValueOps("key1").get();
 System.out.println(s);
 }
}

九、Redis淘汰策略

Redis是基于内存结构进⾏数据缓存的，当内存资源消耗完毕，想要有新的数据缓存进来，必然要从Redis的内存结构中释放⼀些数据。如何进⾏数据的释放呢？----Redis的淘汰策略

Redis提供的8中淘汰策略

理解两个算法名词：

LRU 最久最近未使⽤

LFU 最近最少使⽤

# volatile-lru -> 从设置了过期时间的数据中淘汰最久未使⽤的数据.
# allkeys-lru -> 从所有数据中淘汰最久未使⽤的数据.
# volatile-lfu -> 从设置了过期时间的数据中淘汰使⽤最少的数据.
# allkeys-lfu -> 从所有数据中淘汰使⽤最少的数据.
# volatile-random -> 从设置了过期时间的数据中随机淘汰⼀批数据.
# allkeys-random -> 从所有数据中随机淘汰⼀批数据.
# volatile-ttl -> 淘汰过期时间最短的数据.
# noeviction -> 不淘汰任何数据，当内存不够时直接抛出异常.

⼗、Redis⾼频⾯试题

在项⽬中redis的使⽤场景

⽤于缓存⾸⻚数据

…

Redis的持久化策略
Redis⽀持的数据类型
如何保证redis的⾼可⽤
- Redis⽀持持久化，同时开启rdb 和 aof ，以保证数据的安全性（还是存在数据丢失⻛险的）
- Redis⽀持主从配置，我们可通配置哨兵，实现主备配置，保证可⽤性
- Redis也⽀持集群，通过集群配置可以保证redis的⾼并发
你刚才提到了redis集群，请问如何解决redis集群的脑裂问题？
redis中的数据可以设置过期时间，当数据过期之后有些key并没有及时清除，请问如何处理？