redis-企业级使用

最新推荐文章于 2023-08-27 18:24:22 发布
最新推荐文章于 2023-08-27 18:24:22 发布
阅读量367 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高并发核心技术Redis系列(八)--------企业级解决方案
12-16 1161
一、Redis企业级解决方案 1 RedisDesktopManager 一款好用的Redis桌面管理工具，支持命令控制台操作，以及常用，查询key，rename，delete等操作。 RedisDesktopManager不支持集群操作。 1. 傻瓜式安装该工具 2. 安装成功后，启动该工具 3. 启动后，创建新的连接 4. 创建连接成功 5. 双击进入数据库，可以查看所有的key及value、过期时间，同时可以修改key或删除key 6. 在数据库上右键可...
黑马点评 redis企业级实战
最新发布
06-17
黑马点评 redis企业级实战
【Redis】Redis企业级最佳使用规范与实践（Redis专栏实战启动）
小明的Java问道之路
03-15 1404
本文针对在工作中使用Redis的设计规范进行系统性讲解，包括KV的设计，要控制 key 的长度，避免存储 bigkey，选择合适的数据类型，设置内存上限等等，还有，命令的设计规范，比如禁止使用keys命令进行正则匹配，一些禁止使用的命令，避免大批量Key集中过期和过多使用Redis事务功能等等，也给出了Redis管理的操作规范，Redis客户端设计与使用规范，Redis集群架构设计与使用规范。
数据库缓存服务——Redis（企业级）
fajixianshouhu的博客
05-20 1442
一、Redis 主从复制 1、Redis主从复制特性 使用异步复制 一个主服务器可以有多个从服务器 从服务器也可以有自己的从服务器 复制功能不会阻塞主服务器 可以通过复制功能来让主服务器免于执行持久化操作，由从服务器去执行持久化操作即可 关闭主服务器持久化时，复制功能的数据时完全安全的 当配置Redis复制功能时，强烈建议打开主服务器的持久化功能。否则的话，由于延迟问题应该要避免部署的服务自动拉起 2、Redis主从复制原理 redis主从同步有两种方式（或者说两个阶段）：全同步和部分同步
Redis企业级解决方案
m0_64529944的博客
08-27 155
缓存预热就是系统启动前,提前将相关的缓存热点数据直接加载到缓存系统中。避免服务器在刚启动的时候遇到大量请求的冲击所导致宕机。可以让用户在服务器刚启动时就可以直接在缓存系统中查询事先被预热的缓存数据。
16个Redis常见使用场景总结
weixin_45727359的博客
07-30 589
1、缓存String类型例如：热点数据缓存（例如报表、明星出轨），对象缓存、全页缓存、可以提升热点数据的访问数据。2、数据共享分布式String 类型，因为 Redis 是分布式的独立服务...
Redis在企业级的应用实战-带书签
01-21
Redis 在企业级应用中扮演着重要的角色，尤其在高并发和复杂场景下，其高效的数据存储和处理能力受到广泛认可。本文将深入探讨 Redis 的多种应用场景、架构实践以及华为云的 GaussDB(for Redis) 为企业级用户提供的...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
项目描述 在上家公司自己集成的一套系统，用了两个多月的时间完成的：Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级开发系统 Springboot作为容器，使用mybatis作为持久层框架 使用官方推荐的thymeleaf做为...
Redis企业级运用常见问题
03-28
当前企业级缓存击穿,缓存雪崩常见解决办法
Redis-4.x-Cookbook:Redis 4.x Cookbook的代码文件
05-28
它的多功能性和它启用的各种用例使它成为许多企业的热门数据库选择。 本书以最新版本的Redis为基础，提供了循序渐进的食谱以及相关的背景信息，以充分利用其功能。 它涵盖了从对Redis数据类型的基本理解到Redis高...
Redis配置详解和企业级项目应用架构
07-24
Redis配置详解和企业级项目应用架构。相互学习。共同进步
公司redis
alii79643的博客
04-12 135
一: redis cluster介绍篇 1:rediscluster的现状目前redis支持的cluster特性(已亲测):1):节点自动发现2):slave->master选举,集群容错3):Hotresharding:在线分片4):进群管理:clusterxxx5):基于配置(nodes-port.conf)的集群管理6):ASK转向/MOVED...
redis的对账功能
newlilu的博客
05-18 808
背景：近期在同步数据的使用到了redis的对账方法，处理起来高效，便捷。 public class TestRedis { @Autowired private RedisTemplate redisTemplate; public static final String hashNameA = "test-data-hashNameA"; public static final String hashNameB = "test-data-hashNameB"; .
一文详解Redis企业版软件！
hongcloudtech的博客
11-16 739
虹科Redis企业版软件是企业级的数据库软件，具有8大核心功能、7大特有模块，能以任何规模在云、本地和混合部署中运行现代应用程序，为企业提供无服务器、多模型的数据库解决方案。
浅谈企业中redis运用在项目中的基础方法
晨曦的博客
03-05 1973
静态块初始化redis连接池static { try { JedisPoolConfig config = new JedisPoolConfig(); config.setMaxTotal(MAX_ACTIVE);//可用实例连接最大数量，如果pool已经分配了maxActive个jedis实例，则此时poo...
企业级Redis数据库高可用解决方案
神一样的存在
06-20 3263
企业级Redis数据库高可用解决方案   背景： 最近比较火的Redis非关系数据，可基于内存亦可持久化的日志型、Key-Value数据库。由于服务器的内存管理能力有限，使用过大内存的Redis又会使得服务器的性能急剧下降，一旦服务器发生故障将会影响更大范围业务，集群功能还不适合生产环境的使用集群中超过半数的节点检测失效导致整个集群异常。 在实际特定的应用场景通过Redis的特性提高效率，
Redis企业级部署
qq_37457564的博客
09-04 416
一、单机版Redis安装 1.去redis官网下载一个最新版的Linux版redis包，（就是后缀为.tar.gz的） 2.安装一些必要的环境 wget http://downloads.sourceforge.net/tcl/tcl8.6.1-src.tar.gz tar -xzvf tcl8.6.1-src.tar.gz cd /usr/local/tcl8.6.1/unix/ ...
Redis企业级应用问题
小码哥222的博客
07-12 105
ref：https://www.bilibili.com/video/BV1Rv41177Af?p=40 系列文章目录 文章目录系列文章目录前言1.pandas是什么？1.1总结 前言 1.pandas是什么？ 1.1 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
redis集群企业级搭建
06-09
以下是一个简单的企业级 Redis 集群搭建步骤： 1. 安装 Redis 软件包：在所有 Redis 集群节点上安装 Redis 软件包，并确保版本一致。 2. 配置 Redis 节点：配置每个 Redis 节点的 redis.conf 文件，将节点配置为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值