redis(三) 集群模式---主从模式（master slave ）

已于 2024-06-27 01:22:04 修改
阅读量410 收藏 8
点赞数 5
分类专栏： redis 文章标签： redis
于 2024-06-04 13:49:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chou_qi/article/details/139440752
版权

主从模式

版本：redis 7.0.12
1.编译

  • make
  • make test
    master 节点
    在这里插入图片描述
mv redis-7.0.12 redis-7.0.12_m_s
cp redis.conf redis.conf.bak
# 后台运行
daemonize yes   
# 外部可访问
bind 0.0.0.0
# 服务端口
port 6379
# dump 文件位置
dbfilename dump.rdb
# 进程id
pidfile /home/czh/redis_m_s/redis_6379.pid
logfile "/home/czh/redis_m_s/redis.log"
# masterauth 123456
# 配置密码
requirepass 123456
# aof文件
appendfilename "appendonly.aof"
# aof文件路径
appenddirname "appenddirname"

2.启动master
在这里插入图片描述
在这里插入图片描述

修改
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

启动成功
在这里插入图片描述

3.从节点配置
配置
bind 0.0.0.0
port 6379
daemonize yes
pidfile /home/czh/redis_m_s/redis_6379.pid
logfile “/home/czh/redis_m_s/redis.log”
dir /home/czh/redis_m_s/
replicaof 192.168.0.231 6379
masterauth 123456
replica-read-only yes
requirepass 123456
appendfilename “appendonly.aof”
appenddirname “appendonlydir”
appendfsync everysec
4.启动 232 233 从节点
./redis-server redis.conf
日志
在这里插入图片描述

5.集群信息
info 查看集群信息

OK
127.0.0.1:6379> info
# Server
redis_version:7.0.12
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:6e047769ded62547
redis_mode:standalone
os:Linux 5.15.0-107-generic x86_64
arch_bits:64
monotonic_clock:POSIX clock_gettime
multiplexing_api:epoll
atomicvar_api:c11-builtin
gcc_version:11.4.0
process_id:2487
process_supervised:no
run_id:2e8bd37e9ebe61e8e1e1bc647e5e7b8276c7681c
tcp_port:6379
server_time_usec:1716197973719948
uptime_in_seconds:9323
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:4921941
executable:/home/czh/redis-7.0.12/./redis-server
config_file:/home/czh/redis-7.0.12/./redis.conf
io_threads_active:0

# Clients
connected_clients:2
cluster_connections:0
maxclients:10000
client_recent_max_input_buffer:24
client_recent_max_output_buffer:0
blocked_clients:0
tracking_clients:0
clients_in_timeout_table:0

# Memory
used_memory:957600
used_memory_human:935.16K
used_memory_rss:5738496
used_memory_rss_human:5.47M
used_memory_peak:975680
used_memory_peak_human:952.81K
used_memory_peak_perc:98.15%
used_memory_overhead:883156
used_memory_startup:858848
used_memory_dataset:74444
used_memory_dataset_perc:75.38%
allocator_allocated:990536
allocator_active:1310720
allocator_resident:3891200
total_system_memory:4064755712
total_system_memory_human:3.79G
used_memory_lua:31744
used_memory_vm_eval:31744
used_memory_lua_human:31.00K
used_memory_scripts_eval:0
number_of_cached_scripts:0
number_of_functions:0
number_of_libraries:0
used_memory_vm_functions:32768
used_memory_vm_total:64512
used_memory_vm_total_human:63.00K
used_memory_functions:184
used_memory_scripts:184
used_memory_scripts_human:184B
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.32
allocator_frag_bytes:320184
allocator_rss_ratio:2.97
allocator_rss_bytes:2580480
rss_overhead_ratio:1.47
rss_overhead_bytes:1847296
mem_fragmentation_ratio:6.14
mem_fragmentation_bytes:4803784
mem_not_counted_for_evict:0
mem_replication_backlog:20508
mem_total_replication_buffers:20504
mem_clients_slaves:0
mem_clients_normal:3616
mem_cluster_links:0
mem_aof_buffer:0
mem_allocator:jemalloc-5.2.1
active_defrag_running:0
lazyfree_pending_objects:0
lazyfreed_objects:0

# Persistence
loading:0
async_loading:0
current_cow_peak:0
current_cow_size:0
current_cow_size_age:0
current_fork_perc:0.00
current_save_keys_processed:0
current_save_keys_total:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1716188650
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:-1
rdb_current_bgsave_time_sec:-1
rdb_saves:0
rdb_last_cow_size:0
rdb_last_load_keys_expired:0
rdb_last_load_keys_loaded:0
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_rewrites:0
aof_rewrites_consecutive_failures:0
aof_last_write_status:ok
aof_last_cow_size:0
module_fork_in_progress:0
module_fork_last_cow_size:0

# Stats
total_connections_received:1
total_commands_processed:926
instantaneous_ops_per_sec:0
total_net_input_bytes:13371
total_net_output_bytes:344163
total_net_repl_input_bytes:13195
total_net_repl_output_bytes:0
instantaneous_input_kbps:0.00
instantaneous_output_kbps:0.02
instantaneous_input_repl_kbps:0.00
instantaneous_output_repl_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
expire_cycle_cpu_milliseconds:0
evicted_keys:0
evicted_clients:0
total_eviction_exceeded_time:0
current_eviction_exceeded_time:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
pubsubshard_channels:0
latest_fork_usec:0
total_forks:0
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0
total_active_defrag_time:0
current_active_defrag_time:0
tracking_total_keys:0
tracking_total_items:0
tracking_total_prefixes:0
unexpected_error_replies:0
total_error_replies:7
dump_payload_sanitizations:0
total_reads_processed:933
total_writes_processed:9263
io_threaded_reads_processed:0
io_threaded_writes_processed:0
reply_buffer_shrinks:2
reply_buffer_expands:0

# Replication
role:slave
master_host:192.168.0.231
master_port:6379
master_link_status:up
master_last_io_seconds_ago:9
master_sync_in_progress:0
slave_read_repl_offset:12978
slave_repl_offset:12978
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:1aa927fe638024e8267df28430f04908ebefbf63
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:12978
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:43
repl_backlog_histlen:12936

# CPU
used_cpu_sys:19.811815
used_cpu_user:3.080618
used_cpu_sys_children:0.000000
used_cpu_user_children:0.000000
used_cpu_sys_main_thread:19.806438
used_cpu_user_main_thread:2.996082

# Modules

# Errorstats
errorstat_ERR:count=3
errorstat_NOAUTH:count=3
errorstat_WRONGPASS:count=1

# Cluster
cluster_enabled:0

# Keyspace

连接例子：

（1）Redisson 连接

pom.xml

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.30.0</version>
        </dependency>

MasterSlaveServersRedissonConfig.java

package com.cjs.redisson.example.cjsredissonexample.config;

import org.redisson.api.RedissonClient;
import org.redisson.config.MasterSlaveServersConfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.redisson.config.Config;
import org.redisson.Redisson;

/**
 * 主从配置
 */
@Configuration
public class MasterSlaveServersRedissonConfig {
    @Bean("redissonClient")
    public RedissonClient redissonClient() {

        Config config = new Config();

        // 设置主节点信息
        MasterSlaveServersConfig serverConfig = config.useMasterSlaveServers()
         // 主节点地址和端口
        .setMasterAddress("redis://192.168.0.231:6379")
        // 主节点密码
        .setPassword("123456"); 

        // 可以添加一个或多个从节点
        serverConfig.addSlaveAddress("redis://192.168.0.232:6379", 
        "redis://192.168.0.231:6379");

        // 创建RedissonClient实例
        RedissonClient redissonClient = Redisson.create(config);

        return redissonClient;
    }
}

(2) jredis 连接
pom.xml

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

@Bean
public JedisPoolConfig jedisPoolConfig() {
    JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    jedisPoolConfig.setMaxTotal(10);
    jedisPoolConfig.setMaxIdle(5);
    jedisPoolConfig.setMinIdle(1);
    jedisPoolConfig.setMaxWaitMillis(3000);
    jedisPoolConfig.setTestOnBorrow(true);
    return jedisPoolConfig;
}

@Bean
public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
    JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
    jedisConnectionFactory.setHostName("192.168.0.231");
    jedisConnectionFactory.setPort(6379);
    jedisConnectionFactory.setUsePool(true);
    jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
    return jedisConnectionFactory;
}

@Autowired
private JedisConnectionFactory jedisConnectionFactory;
public void operateRedis() {
    RedisConnection connection = jedisConnectionFactory.getConnection();
    connection.set("key", "value".getBytes());
    byte[] value = connection.get("key".getBytes());
    System.out.println(new String(value));
    connection.close();
}

(3) Lettuce 连接
pom.xml

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>3.3.0</version>
</dependency>

yaml

spring:
  redis:
    database: 0
    host: 192.168.0.231
    port: 6379
    password: 123456 
    lettuce:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0
    timeout: 2000

@Configuration
public class LettuceRedisConfig {
  @Bean
  public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
 // 创建一个新的RedisTemplate实例，用于操作Redis  
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();  
        // 设置RedisTemplate使用的连接工厂，以便它能够连接到Redis服务器  
        redisTemplate.setConnectionFactory(connectionFactory);  
          
        // 创建一个StringRedisSerializer实例，用于序列化Redis的key为字符串  
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
          
        // 创建一个Jackson2JsonRedisSerializer实例，用于序列化Redis的value为JSON格式  
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);  
          
        // 创建一个ObjectMapper实例，用于处理JSON的序列化和反序列化  
        ObjectMapper objectMapper = new ObjectMapper();  
          
        // 设置ObjectMapper的属性访问级别，以便能够序列化对象的所有属性  
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
          
        // 启用默认的类型信息，以便在反序列化时能够知道对象的实际类型  
        // 注意：这里使用了新的方法替换了过期的enableDefaultTyping方法  
        // 方法过期，改为下面代码  
        // objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
          
        // 设置Jackson2JsonRedisSerializer使用的ObjectMapper  
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);  
  
        // 设置RedisTemplate的key序列化器为stringRedisSerializer  
        redisTemplate.setKeySerializer(stringRedisSerializer); // key的序列化类型  
        // 设置RedisTemplate的value序列化器为jackson2JsonRedisSerializer  
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型  
          
        // 设置RedisTemplate的hash key序列化器为stringRedisSerializer  
        redisTemplate.setHashKeySerializer(stringRedisSerializer);  // key的序列化类型  
        // 设置RedisTemplate的hash value序列化器为jackson2JsonRedisSerializer  
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);   // value的序列化类型  
        
        // 调用RedisTemplate的afterPropertiesSet方法，该方法会执行一些初始化操作，比如检查序列化器是否设置等  
        redisTemplate.afterPropertiesSet();  
          
        // 返回配置好的RedisTemplate实例  
        return redisTemplate;  
  }
}

package com.lsqingfeng.springboot.utils;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
 
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 

@Component
public class RedisUtil {
 
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 给一个指定的 key 值附加过期时间
     *
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public long getTime(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 移除指定key 的过期时间
     *
     * @param key
     * @return
     */
    public boolean persist(String key) {
        return redisTemplate.boundValueOps(key).persist();
    }
 
    //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -
 
    /**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
 
    /**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    /**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value);
        }
    }
 
    /**
     * 批量添加 key (重复的键会覆盖)
     *
     * @param keyAndValue
     */
    public void batchSet(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSet(keyAndValue);
    }
 
    /**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     *
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    }
 
    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     *
     * @param key
     * @param number
     */
    public Long increment(String key, long number) {
        return redisTemplate.opsForValue().increment(key, number);
    }
 
    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     *
     * @param key
     * @param number
     */
    public Double increment(String key, double number) {
        return redisTemplate.opsForValue().increment(key, number);
    }
 
    //- - - - - - - - - - - - - - - - - - - - -  set类型 - - - - - - - - - - - - - - - - - - - -
 
    /**
     * 将数据放入set缓存
     *
     * @param key 键
     * @return
     */
    public void sSet(String key, String value) {
        redisTemplate.opsForSet().add(key, value);
    }
 
    /**
     * 获取变量中的值
     *
     * @param key 键
     * @return
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }
 
    /**
     * 随机获取变量中指定个数的元素
     *
     * @param key   键
     * @param count 值
     * @return
     */
    public void randomMembers(String key, long count) {
        redisTemplate.opsForSet().randomMembers(key, count);
    }
 
    /**
     * 随机获取变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }
 
    /**
     * 弹出变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop("setValue");
    }
 
    /**
     * 获取变量中值的长度
     *
     * @param key 键
     * @return
     */
    public long size(String key) {
        return redisTemplate.opsForSet().size(key);
    }
 
    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }
 
    /**
     * 检查给定的元素是否在变量中。
     *
     * @param key 键
     * @param obj 元素对象
     * @return
     */
    public boolean isMember(String key, Object obj) {
        return redisTemplate.opsForSet().isMember(key, obj);
    }
 
    /**
     * 转移变量的元素值到目的变量。
     *
     * @param key     键
     * @param value   元素对象
     * @param destKey 元素对象
     * @return
     */
    public boolean move(String key, String value, String destKey) {
        return redisTemplate.opsForSet().move(key, value, destKey);
    }
 
    /**
     * 批量移除set缓存中元素
     *
     * @param key    键
     * @param values 值
     * @return
     */
    public void remove(String key, Object... values) {
        redisTemplate.opsForSet().remove(key, values);
    }
 
    /**
     * 通过给定的key求2个set变量的差值
     *
     * @param key     键
     * @param destKey 键
     * @return
     */
    public Set<Set> difference(String key, String destKey) {
        return redisTemplate.opsForSet().difference(key, destKey);
    }
 
 
    //- - - - - - - - - - - - - - - - - - - - -  hash类型 - - - - - - - - - - - - - - - - - - - -
 
    /**
     * 加入缓存
     *
     * @param key 键
     * @param map 键
     * @return
     */
    public void add(String key, Map<String, String> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }
 
    /**
     * 获取 key 下的 所有  hashkey 和 value
     *
     * @param key 键
     * @return
     */
    public Map<Object, Object> getHashEntries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
 
    /**
     * 验证指定 key 下 有没有指定的 hashkey
     *
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }
 
    /**
     * 获取指定key的值string
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public String getMapString(String key, String key2) {
        return redisTemplate.opsForHash().get("map1", "key1").toString();
    }
 
    /**
     * 获取指定的值Int
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public Integer getMapInt(String key, String key2) {
        return (Integer) redisTemplate.opsForHash().get("map1", "key1");
    }
 
    /**
     * 弹出元素并删除
     *
     * @param key 键
     * @return
     */
    public String popValue(String key) {
        return redisTemplate.opsForSet().pop(key).toString();
    }
 
    /**
     * 删除指定 hash 的 HashKey
     *
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */
    public Long delete(String key, String... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }
 
    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey, long number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }
 
    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Double increment(String key, String hashKey, Double number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }
 
    /**
     * 获取 key 下的 所有 hashkey 字段
     *
     * @param key
     * @return
     */
    public Set<Object> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }
 
    /**
     * 获取指定 hash 下面的 键值对 数量
     *
     * @param key
     * @return
     */
    public Long hashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }
 
    //- - - - - - - - - - - - - - - - - - - - -  list类型 - - - - - - - - - - - - - - - - - - - -
 
    /**
     * 在变量左边添加元素值
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPush(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }
 
    /**
     * 获取集合指定位置的值。
     *
     * @param key
     * @param index
     * @return
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index("list", 1);
    }
 
    /**
     * 获取指定区间的值。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }
 
    /**
     * 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
     * 如果中间参数值存在的话。
     *
     * @param key
     * @param pivot
     * @param value
     * @return
     */
    public void leftPush(String key, String pivot, String value) {
        redisTemplate.opsForList().leftPush(key, pivot, value);
    }
 
    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void leftPushAll(String key, String... values) {
//        redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().leftPushAll(key, values);
    }
 
    /**
     * 向集合最右边添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPushAll(String key, String value) {
        redisTemplate.opsForList().rightPush(key, value);
    }
 
    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void rightPushAll(String key, String... values) {
        //redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().rightPushAll(key, values);
    }
 
    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void rightPushIfPresent(String key, Object value) {
        redisTemplate.opsForList().rightPushIfPresent(key, value);
    }
 
    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @return
     */
    public long listLength(String key) {
        return redisTemplate.opsForList().size(key);
    }
 
    /**
     * 移除集合中的左边第一个元素。
     *
     * @param key
     * @return
     */
    public void leftPop(String key) {
        redisTemplate.opsForList().leftPop(key);
    }
 
    /**
     * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void leftPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().leftPop(key, timeout, unit);
    }
 
    /**
     * 移除集合中右边的元素。
     *
     * @param key
     * @return
     */
    public void rightPop(String key) {
        redisTemplate.opsForList().rightPop(key);
    }
 
    /**
     * 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void rightPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().rightPop(key, timeout, unit);
    }
}


// 在需要的类中引用
@Resource
private RedisUtils redisUtils;

// 然后在需要的地方使用
redisUtils.set(phone, phoneCode, 60, TimeUnit.SECONDS);

(4) python 连接

# redis-py库    pip install redis
import redis
 
# 连接到本地运行的Redis服务
redis_client = redis.StrictRedis(host='192.168.0.231', port=6379, db=0)
 
# 或者使用连接池来管理多个连接
pool = redis.ConnectionPool(host='192.168.0.231', port=6379, db=0)
redis_client = redis.StrictRedis(connection_pool=pool)
 
# 测试连接
redis_client.set('test_key', '100')
value = redis_client.get('test_key')
print(value)  # 应该输出 b'100'

(5) go 连接

 /*使用go-redis/redis包 安装go-redis/redis包*/
 
go get github.com/redis/go-redis/v9

/*Go代码连接到Redis服务器：*/
package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
)

func main() {
	// 创建Redis客户端
	rdb := redis.NewClient(&redis.Options{
		Addr:     "192.168.0.231:6379", // Redis服务器地址
		Password: "123456",             // 密码，没有则留空
		DB:       0,                    // 使用默认DB
	})

	ctx := context.Background()

	// 设置键值
	err := rdb.Set(ctx, "test_key", "test_value", 0).Err()
	if err != nil {
		panic(err)
	}

	// 获取键值
	val, err := rdb.Get(ctx, "test_key").Result()
	if err != nil {
		panic(err)
	}

	fmt.Println("key", val) // 输出: key value

	// 关闭客户端连接
	err = rdb.Close()
	if err != nil {
		panic(err)
	}
}

上述例子代码
redis_ms_redission.
python_ms_redis
go_redis

Redis集群形式--哨兵模式集群和高可用模式集群---Redis学习笔记003
添柴程序猿的专栏
06-08 391
对于redis集群,我们搭建的时候可以选择两种模式:这里记录一下,至于如何搭建,网上教程太多了,这里不多说了,记录一下到时候用到时候,可以想到应该使用哪种模式,到时候去搭建就可以了哨兵模式的集群:在redis3.0以前的版本要实现集群一般是借助哨兵sentinel工具来监控master节点的状态，如果master节点异常，则会做主从切换，将某一台slave作为master，哨兵的配置略微复杂，并且性能和高可用性等各方面表现一般，特别是在主从切换的瞬间存在访问瞬断的情况，而且哨兵模式只有一个主节点对外提供服务
Window环境Redis-Master-Slave-主从配置
03-02
Window环境Redis-Master-Slave-主从配置，解压后查看readme，直接启动，就可以进行Redis的主从操作了！
redis 学习笔记(3)-master/slave（主/从模式）
weixin_34236869的博客
11-19 284
类似mysql的master-slave模式一样，redis的master-slave可以提升系统的可用性，master节点写入cache后，会自动同步到slave上。 环境： master node: 10.6.144.155:7030 slave node: 10.6.144.156:7031   一、配置 仅需要在slave node上修改配置： 找到slaveof这行，参考下...
Redis主从复制（Master-Slave Replication）解析与搭建操作指南
最新发布
IT成长日记的博客
03-19 737
Redis主从复制是实现高可用性和扩展性的关键技术。通过合理配置和使用，可以提升Redis的性能和可靠性。在实际应用中，可以结合Redis Sentinel或Redis Cluster实现更强大的高可用方案。
redis master slave
luckgl的博客
03-13 782
复制原理 第一次全量,然后增量 一主 多从 / 一从 master slave 重启后 之间的主从关系 master restart slave normal keep master-slave(主从正常) master normal slave restart fail master-slave (主从破裂) master (a) &lt;–slave(b)&lt;–...
【周阳-Redis】【08】Redis的Master-Slave
Keep Reading Keep Writing Keep Thinking
05-29 1276
持续学习&持续更新中… 守破离 【周阳-Redis】【08】Redis的Master-SlaveRedis的Master-Slave单机多Redis实例搭建环境怎么玩常用三招一主多仆反客为主薪火相传（去中心化）哨兵模式（sentinel）是什么怎么玩主从复制原理主从复制缺点参考 Redis的Master-Slave 行话：也就是我们所说的主从复制，主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制 Master以写为主，Slave以读为主 可以实现的主要功能： 读写.
redis-master-slave
java 学习路
01-06 208
Redis复制工作原理： 1. 如果设置了一个Slave，无论是第一次连接还是重连到Master，它都会发出一个SYNC命令；2. 当Master收到SYNC命令之后，会做两件事：a) Master执行BGSAVE，即在后台保存数据到磁盘（rdb快照文件）；b) Master同时将新收到的写入和修改数据集的命令存入缓冲区（非查询类）；3. 当Master在后台把数据保存到快照文件完成之后，...
【Redis】Docker下部署Redis集群----Redis Cluster(主从集群)
AloneYueCSDN
10-28 652
文章目录1.原文链接2.操作 1.原文链接 Docker部署Redis集群----第十二节（docker-redis-cluster集群理论篇） Docker部署Redis集群----第十三节（docker-Compose介绍） 2.操作
Redis分布式集群----哨兵模式来进行主从替换以及故障恢复(3)
Chen的博客
11-01 675
一、哨兵模式？
使用DockerCompose配置基于哨兵模式的redis主从架构集群
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
04-15 1812
使用DockerCompose配置基于哨兵模式的redis主从架构集群，分享了几个易错点。
redis主从[master、slave]
老明
11-09 395
[size=large] 主从复制:让多个slave server拥有和master server相同的数据库副本。 特点 1.master可以有多个slave 2.除了多个slave连到相同的master外，slave也可以连接其他slave形成图状结构 3.主从复制不会阻塞master。也就是说当一个或多个slave与master进行初次同步数据时，master可以继续处理c...
Redis集群、主从复制、哨兵配置
01-30
Redis创建集群及主从复制，哨兵配置，动态新增节点和删除节点后集群的可用性，插槽的分配机制等。
Redis的复制(MasterSlave)
01-09
Redis的复制(Master/Slave) 1.是什么 1.1官网 … 1.2行话 也就是我们所说的主从复制，主机数据更新后根据配置和策略自动同步到备机的master/slave机制，Master以写为主，Slave以读为主。 2.能干嘛 2.1读写分离 2.2容灾恢复 3.怎么玩 3.1配从(库)不配主(库) 3.2从库配置:salveof 主库IP 主库端口 3.2.1 每次与master断开之后，都需要重新连接，除非你配置进redis.conf文件 3.2.2 Info replication 3.3修改配置文件细节操作 1.拷贝多个redis.conf文件 2.开启daemonize
Redis的master/slave简单实现
liguoxing81的专栏
11-02 751
在做此时之前肯定需要先下载Redis。下载地址：https://github.com/MSOpenTech/redis/releases。下载的是最新版本3.2.1，下载完之后解压。     下面具体说一下具体步骤： 1、将解压之后的Redis放到C盘，因为是要设置主从关系所以该目录下放了两个，分别是Redis和redis2。 2、打开redis2目录下的redis.windows.conf
redis实现master－slave分布式
专注！！！
07-31 1651
1、copy一下redis.conf（在redis-server文件夹中），生成一个从机的配置，拷贝到var/redis_slave.conf 2、修改主服务器的配置redis.conf，修改内容如下（以下是以本机做为主从服务器）：    bind 127.0.0.1 3、修改从服务器的配置redis_slave.conf，修改内容如下：    port 10002（从服务器的端口）
Redis集群——主从配置
m0_50786325的博客
05-14 1177
配置一主二从 host port role 192.168.186.200 6379 master 192.168.186.201 6379 slave 192.168.186.202 6379 slave 第一步、配置 master （1）进入 192.168.186.200，打开终端，在根目录下创建工作目录：/redis-master cd / mkdir /redis-master cd /redis-master （2）将 redis.conf 文件复制到 /redis
redis集群（主从配置）
不积跬步,无以至千里;不积小流,无以成江海
09-15 740
市面上太多kv的缓存，最常用的就属memcache了，但是memcache存在单点问题，不过小日本有复制版本，但是使用的人比较少，redis的出现让kv内存存储的想法成为现实。今天主要内容便是redis主从实现简单的集群，实际上redis的安装配置砸门ttlsa之前就有个文章，废话少说，进入正题吧 Redis简介 redis是一个key-value存储系统。和Memcached类似，它支持存储
Redis之Master/Slave-主从复制
风清云淡
12-22 1913
一、Master/Slave Redis对于数据持久化前面介绍过rdb和aof，这两种方式都是在同一台机器上进行读写操作，如果在高并发下对于服务器将是很大考验，所以一般都是读写分离，一台负责写，一台负责读。 Redis的复制(Master/Slave)，也就是我们所说的主从复制，主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主。...
Redis基础篇-13-Redis的复制（Master/Slave）
Alan0517
04-09 411
启动哨兵：上述目录依照各自的实际情况配置，可能目录不同正常主从演示 原的master挂了 投票新选 重新主从继续开工，info replication查查看。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值