redis-企业级使用

最新推荐文章于 2023-08-27 18:24:22 发布
最新推荐文章于 2023-08-27 18:24:22 发布
阅读量423 收藏 1
点赞数
分类专栏： redis 文章标签： redis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kk_lina/article/details/126075790
版权

一、事务

ACID，在redis中命令是保证原子性的，但是redis事务中不保证原子性和隔离级别的概念，说明不可能出现幻读、脏读等情况。
Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行，一次性、顺序性、排他性！执行一些列的命令！

1、事务执行过程

redis的事务：入队的时候并不会去执行，只有当执行的时候才会一次性执行。

  • 开启事务：multi
  • 命令入队：输入命令
  • 执行事务：exec
  • 取消事务：DISCARD

每次执行完事务之后事务默认关闭或删除，需要再次创建事务。

2、事务的异常处理

编译型异常(代码有问题，命令有错)，启动就会报错，所有命令都不会被执行！
运行时异常(1/0)，如果事务队列中存在语法行错误，其他命令是可以正常执行的，错误命令抛出异常！

3、监控

悲观锁：无论做什么都加锁
乐观锁：不会上锁，更新数据时会判断一下在此期间是否有人修改过数据。
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
OK
127.0.0.1:6379(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> incrby out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20

乐观锁：当watch该对象后，使用事务修改对象的值，但是并未提交时，此时其它线程同时修改该对象的值并且执行，那么这个事务执行后会返回一个nil值提示该事务执行失败。 此时想要再次操作需要使用unwatch解锁然后获取到最新值之后再执行相关事务的命令。

在这里插入图片描述

二、Jedis

Redis官方推荐的java链接开发工具，使用java操作redis中间件！如果使用java操作redis，那么一定要对jedis十分的熟悉！

  1. 导入依赖
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.2.3</version>
</dependency> 

public class RedisJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        // 如果 Redis 服务设置了密码，需要下面这行，没有就不需要
        // jedis.auth("123456"); 
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
    }
}
  • 整合事务
    在这里插入图片描述

三、SpringBoot整合redis

SpringBoot操作数据：spring-data jpa jdbc mongodb redis!
SpringData也是和SpringBoot齐名的项目！
说明：在springboot2.x之后，原来使用的jedis被替换成了lettuce，lettuce底层采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况，可以减少线程数，更像nio模式。jedis采用的直连，多个线程操作的话是不安全的，如果想避免不安全的，使用jedis pool连接池！
配置文件源码分析：
在这里插入图片描述
当自己自定义redistemplate时，会覆盖redistemplat，除此之外，因为string类型是最常使用的，所以源码还提供了一个专门针对String类型的template。

  • 引入依赖
  • 编写配置
    本地配置：
spring:
    redis:
      host: 127.0.0.1
      port: 6379
      password: 
      jedis:
        pool:
          max-active: 8
          max-wait: -1ms
          max-idle: 500
          min-idle: 0
      lettuce:
        shutdown-timeout: 0ms

  • 注入bean

  • 使用redistemplate完成一些基本操作，和redis的命令是一样的在这里插入图片描述
    redistemplate默认序列化是使用jdk，可以自己定义一个配置类，编写自己的redistemplate定义自己的序列化方式，在使用存储对象时，所有对象都需要进行序列化存储，否则会报错，但是一般时候存储的都是json格式，而不会直接存储对象。
    redis序列化配置：

package com.kuang.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;

@Configuration
public class RedisConfig {

  @Bean
  @SuppressWarnings("all")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
      template.setConnectionFactory(factory);
      Jackson2JsonRedisSerializer 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);
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

      // key采用String的序列化方式
      template.setKeySerializer(stringRedisSerializer);
      // hash的key也采用String的序列化方式
      template.setHashKeySerializer(stringRedisSerializer);
      // value序列化方式采用jackson
      template.setValueSerializer(jackson2JsonRedisSerializer);
      // hash的value序列化方式采用jackson
      template.setHashValueSerializer(jackson2JsonRedisSerializer);
      template.afterPropertiesSet();

      return template;
  }


}

在企业中开发一般很少使用原生的方法去操作redis，一般都自己封装工具类 RedisUtils.java

package com.kuang.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 递增
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 递减
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */

    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */

    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */

    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }

    }

}
kk_lina
关注
专栏目录
高并发核心技术Redis系列(八)--------企业级解决方案
12-16 1204
一、Redis企业级解决方案 1 RedisDesktopManager 一款好用的Redis桌面管理工具，支持命令控制台操作，以及常用，查询key，rename，delete等操作。 RedisDesktopManager不支持集群操作。 1. 傻瓜式安装该工具 2. 安装成功后，启动该工具 3. 启动后，创建新的连接 4. 创建连接成功 5. 双击进入数据库，可以查看所有的key及value、过期时间，同时可以修改key或删除key 6. 在数据库上右键可...
Redis-企业级解决方案
zhangxuelong461的博客
01-15 389
企业级解决方案 1.缓存预热 宕机-服务器启动后迅速宕机 问题排查： 请求数量较高 主从之间数据吞吐量较大，数据同步操作频度较高 解决方案 前置准备工作： 日常例行统计数据访问记录，统计访问频度较高的热点数据 利用LRU数据删除策略，构建数据留存队列。例如：storm与kafka配合 准备工作 将统计结果中的数据分类，根据级别，redis优先加载级别较高的热点数据 利用分布式多服务器同时...
Redis 企业级应用
luoqing_LH的博客
12-08 226
Redis缓存预热、缓存击穿、缓存雪崩、缓存穿透
公司redis
alii79643的博客
04-12 151
一: redis cluster介绍篇 1:rediscluster的现状目前redis支持的cluster特性(已亲测):1):节点自动发现2):slave->master选举,集群容错3):Hotresharding:在线分片4):进群管理:clusterxxx5):基于配置(nodes-port.conf)的集群管理6):ASK转向/MOVED...
Redis企业应用入门看这篇就够了！
hspnb的博客
10-02 578
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。jedis是java来访问redis数据库的api。
tomcat-redis-session-manager-2.0.0.zip
04-18
总之，`tomcat-redis-session-manager-2.0.0`是解决现代Web应用Session共享问题的理想工具，它结合了Tomcat的稳定性和Redis的高性能，为企业级分布式架构提供了强大支持。无论是小型创业团队还是大型企业，都能从中...
Redis-x64-3.2.100.msi.7z
07-21
总之，Redis是一个强大且灵活的数据库，适用于缓存、队列、计数器、实时数据存储等多种场景，广泛应用于互联网和企业级应用中。`Redis-x64-3.2.100.msi` 文件的下载和安装，为Windows用户提供了便捷的部署方式，使...
redis-5.0.4.tar
05-29
Redis作为一款高效、轻量级的数据库，其特点是快速读写、低延迟和丰富的数据结构，广泛应用于缓存、消息队列、实时统计等多种场景。它的优势在于内存存储，使得数据处理速度极快，但同时也需要注意内存管理，避免...
redis-broker:Redis双写工具，创建Redis双主模式
05-26
Redis是一种高性能的键值数据库，常用于数据缓存、消息队列等场景。在高可用性需求下，Redis提供了多种复制策略，其中双主模式（也称为哨兵模式...通过简化配置和自动化监控，它为企业级应用提供了一种可靠的解决方案。
redis4.0.11-16离线安装包适应于麒麟V10SP1
09-22
麒麟V10SP1是一款基于Linux的国产服务器操作系统，通常用于企业级应用，对安全性、稳定性和性能有较高要求。此离线安装包确保了在麒麟V10SP1环境下可以便捷地安装和运行Redis，无需依赖网络环境，对于那些网络条件...
Redis配置详解和企业级项目应用架构
07-24
Redis配置详解和企业级项目应用架构。相互学习。共同进步
Redis高级之——Redis的企业级应用（预热，雪崩，击穿，穿透）
weixin_45417821的博客
07-31 757
企业级解决方案 缓存预热 缓存预热的思路 a.提前给redis中嵌入部分数据，再提供服务 b.肯定不可能将所有数据都写入redis，因为数据量太大了，第一耗费的时间太长了，第二redis根本就容纳不下所有的数据 c.需要更具当天的具体访问情况，试试统计出频率较高的热数据 d.然后将访问频率较高的热数据写入到redis，肯定是热数据也比较多，我们也得多个服务并行的读取数据去写，并行的分布式的缓存预热 e.然后将嵌入的热数据的redis对外提供服务，这样就不至于冷启动，直接让数据库奔溃了 具体的实时方案：
【Redis】Redis企业级最佳使用规范与实践（Redis专栏实战启动）
小明的Java问道之路
03-15 1740
本文针对在工作中使用Redis的设计规范进行系统性讲解，包括KV的设计，要控制 key 的长度，避免存储 bigkey，选择合适的数据类型，设置内存上限等等，还有，命令的设计规范，比如禁止使用keys命令进行正则匹配，一些禁止使用的命令，避免大批量Key集中过期和过多使用Redis事务功能等等，也给出了Redis管理的操作规范，Redis客户端设计与使用规范，Redis集群架构设计与使用规范。
Redis企业开发的两种使用方式
天天吞吞吐吐跳跳糖
08-09 369
redis的企业开发：1 代码实现 springdataRedis 例：菜品(mysql-redis的数据一致性)2 注解实现 SpringCache 例：套餐(mysql-redis的数据一致性)
Redis 之企业级解决方案
qq15035899256的博客
02-25 745
本文是对Redis的学习，学习了4种Redis在实际应用中的问题，以及它们的企业级解决方案，并且了解了Redis性能指标监控的方法。之后的学习内容将持续更新！！！
数据库缓存服务——Redis（企业级）
fajixianshouhu的博客
05-20 1505
一、Redis 主从复制 1、Redis主从复制特性 使用异步复制 一个主服务器可以有多个从服务器 从服务器也可以有自己的从服务器 复制功能不会阻塞主服务器 可以通过复制功能来让主服务器免于执行持久化操作，由从服务器去执行持久化操作即可 关闭主服务器持久化时，复制功能的数据时完全安全的 当配置Redis复制功能时，强烈建议打开主服务器的持久化功能。否则的话，由于延迟问题应该要避免部署的服务自动拉起 2、Redis主从复制原理 redis主从同步有两种方式（或者说两个阶段）：全同步和部分同步
Redis企业级应用问题
小码哥222的博客
07-12 185
ref：https://www.bilibili.com/video/BV1Rv41177Af?p=40 系列文章目录 文章目录系列文章目录前言1.pandas是什么？1.1总结 前言 1.pandas是什么？ 1.1 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
redis——企业级解决方案
weixin_46317268的博客
08-16 445
企业级解决方案缓存预热缓存雪崩缓存击穿缓存穿透性能指标监控性能指标：Performance内存指标：Memory基本活动指标：Basic activity持久性指标：Persistence错误指标：Error监控方式 缓存预热 现象：服务器启动后迅速宕机 问题排查： 1.请求数量较高 2.主从之间数据吞吐量较大，数据同步操作频度较高 解决方案 前置准备工作： 1.日常例行统计数据访问记录，统计访问频度较高的热点数据 2.利用LRU数据删除策略，构建数据留存队列 例如：storm与kafka配合 准备工作：
Redis企业级解决方案
最新发布
m0_64529944的博客
08-27 180
缓存预热就是系统启动前,提前将相关的缓存热点数据直接加载到缓存系统中。避免服务器在刚启动的时候遇到大量请求的冲击所导致宕机。可以让用户在服务器刚启动时就可以直接在缓存系统中查询事先被预热的缓存数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值