JAVA开发（Redis的主从与集群）

已于 2024-01-04 10:13:54 修改
阅读量3.4k 收藏 55
点赞数 43
分类专栏： java 文章标签： redis java 缓存
于 2023-02-09 11:20:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongjing991/article/details/128949033
版权

现在web项目无处不在使用缓存技术，redis的身影可谓无处不在。但是又有多少项目使用到的是redis的集群？大概很多项目只是用到单机版的redis吧。作为缓存的一块，set ，get数据。用的不亦乐乎。但是对于高可用系统来说，数据集群是很有必要的。

我们看单机版的redis配置。

springBoot引入maven依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>

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

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

配置springboot  yml文件 redis连接

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: 123456
    maxIdle: 20
    minIdle: 10
    maxTotal: 100
    database: 2
    busiDb: 9
    boeDb: 2
    eximportDb: 5
    session:
      store-type: redis
  cache:
    type: redis

操作redis的工具类：

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import com.google.gson.Gson;

import cn.ctg.common.enums.EnumType;
import cn.ctg.common.util.constants.Constant;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;

/**
 * Redis工具类
 *
 */
@Component
public class RedisUtils {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Resource(name = "redisTemplate")
    private ValueOperations<String, String> valueOperations;
 
    @Autowired
    private RedisExtendService redisExtendService;

    /** 加分布式锁的LUA脚本 */
    private static final String LOCK_LUA =
        "if redis.call('setNx',KEYS[1],ARGV[1])==1  then return redis.call('expire',KEYS[1],ARGV[2])  else  return 0 end";

    /** 计数器的LUA脚本 */
    private static final String INCR_LUA =
        "local current = redis.call('incr',KEYS[1]);" +
            " local t = redis.call('ttl',KEYS[1]); " +
            "if t == -1 then  " +
            "redis.call('expire',KEYS[1],ARGV[1]) " +
            "end; " +
            "return current";

    /** 解锁的LUA脚本 */
    private static final String UNLOCK_LUA =
        "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    private static final Long SUCCESS = 1L;

    /** 互斥锁过期时间（分钟） */
    private static final long MUTEX_WAIT_MILLISECONDS = 50;
    /** 编号规则生成线程等待次数 ((10 * 1000) / 50) + 1 */
    public static final long RULE_CODE_THREAD_WAIT_COUNT = 200;
    /** 互斥锁等待时间（毫秒） */
    private static final long MUTEX_EXPIRE_MINUTES = 3;
    
    /**
	     * 不设置过期时长
	*/
	public final static long NOT_EXPIRE = -1;
    
	/**
	     * 默认过期时长，单位：秒 
	*/
	public final static long DEFAULT_EXPIRE = 7200; // 2小时
	
    /**
                * 会员卡缓存失效时间  2小时
     */
    public final static long CARD_DEFAULT_EXPIRE = 7200;
    
    /**
               * 默认过期时长，1天
     */
    public final static long DEFAULT_A_DAY = 86400;
    
    /**
               * 默认过期时长，1分钟
     */
    public final static long DEFAULT_A_MIN = 60 ;
    
    /**
            * 默认过期时长，2分钟
	*/
	public final static long DEFAULT_TWO_MIN = 120 ;

    /**
     * 保存数据
     *
     * @param key
     * @param value
     * @param expire 过期时间，单位s
     */
    public void set(String key, Object value, long expire) {
        String valueJson = toJson(value);
        valueOperations.set(key, valueJson);
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        redisExtendService.redisDataChange(key, valueJson, EnumType.CRUD_TYPE.CREATE.getValue());
    }

    /**
     * 判断key是否存在
     *
     * @param key
     */
    public Boolean hasKey(String key) {
        if (StringUtils.isNotBlank(key)) {
            return valueOperations.getOperations().hasKey(key);
        }
        return Boolean.FALSE;
    }

    /**
     * @param key
     * @param value
     */
    public void set(String key, Object value) {
        set(key, value, NOT_EXPIRE);
    }

    public <T> T get(String key, Class<T> clazz, long expire) {
        String value = Convert.toStr(valueOperations.get(key));
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value == null ? null : fromJson(value, clazz);
    }

    /**
     * 批量从Redis中获取数据
     *
     * @param valueMap 需要存储的数据集合
     * @param expire 过期时间，秒
     * @return java.util.List<T> 返回值
     */
    public void batchSet(Map<String, String> valueMap, long expire) {
        valueOperations.multiSet(valueMap);
        if (expire != NOT_EXPIRE) {
            for (String key : valueMap.keySet()) {
                redisTemplate.expire(key, expire, TimeUnit.SECONDS);
            }
        }
    }

    /**
     * 批量删除
     *
     * @param keys 需要删除的KEY集合
     * @return void
     */
    public void batchDelete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * 批量从Redis中获取数据
     *
     * @param keyList 需要获取的Key集合
     * @param clazz 需要转换的类型
     * @return java.util.List<T> 返回值
     */
    public <T> Map<String, T> batchGet(List<String> keyList, Class<T> clazz) {
        List<String> objectList = valueOperations.multiGet(keyList);
        Map<String, T> map = new LinkedHashMap<>(objectList.size());
        for (int i = 0; i < keyList.size(); i++) {
            String value = Convert.toStr(objectList.get(i));
            if (!String.class.equals(clazz)) {
                map.put(keyList.get(i), fromJson(value, clazz));
            } else {
                map.put(keyList.get(i), (T)value);
            }
        }
        return map;
    }

    public <T> T get(String key, Class<T> clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    /**
     * 使用 父编码+当前编码获取+集团+语言 获取名称
     *
     * @param code 父编码
     * @param dictCode 当前编码
     * @param language 语言 UserUtils.getLanguage()
     * @param groupId 集团ID
     */
    public String get(String code, String dictCode, String language, String groupId) {
        if (StringUtils.isBlank(dictCode)) {
            return "";
        }
        String key = RedisKeys.getSysDictKey(code, dictCode, language, groupId);
        return get(key, NOT_EXPIRE);
    }

    public String get(String key, long expire) {
        String value = Convert.toStr(valueOperations.get(key));
        if (expire != NOT_EXPIRE) {
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
        redisExtendService.redisDataChange(key, "", EnumType.CRUD_TYPE.DELETE.getValue());
    }

    /**
     * Object转成JSON数据
     */
    private String toJson(Object object) {
        if (object instanceof Integer || object instanceof Long || object instanceof Float || object instanceof Double
            || object instanceof Boolean || object instanceof String) {
            return String.valueOf(object);
        }
        return new Gson().toJson(object);
    }

    /**
     * JSON数据，转成Object
     */
    private <T> T fromJson(String json, Class<T> clazz) {
        return new Gson().fromJson(json, clazz);
    }

    /**
     * 获取分布式锁，默认过期时间3分钟
     *
     * @param key 锁的KEY
     * @return java.lang.Boolean true为获取到锁,可以下一步业务, false为没有获取到锁
     */
    public Boolean setMutexLock(String key) {
        return setMutexLockAndExpire(key, getMutexLockExpireMinutes(), TimeUnit.MINUTES);
    }

    /**
     * 获取分布式锁，带Redis事务
     *
     * @param key 锁的KEY
     * @param timeout 锁时效时间,默认单位：秒
     * @param unit 锁失效时间单位，为null则默认秒
     * @return java.lang.Boolean true为获取到锁,可以下一步业务, false为没有获取到锁
     */
    public Boolean setMutexLockAndExpire(String key, long timeout, TimeUnit unit) {
        return setMutexLockAndExpire(key, Constant.RESULT_1, timeout, unit);
    }

    /**
     * 获取分布式锁，带Redis事务
     * 适用于同一业务，不同的请求用不同的锁，把value当成
     * @param key 锁的KEY
     * @param value 锁的值，一定要跟解锁的值一样，否则会导致无法解锁
     * @param timeout 锁时效时间,默认单位：秒
     * @param unit 锁失效时间单位，为null则默认秒
     * @return java.lang.Boolean true为获取到锁,可以下一步业务, false为没有获取到锁
     */
    public Boolean setMutexLockAndExpire(String key, String value, long timeout, TimeUnit unit) {
        value = StrUtil.appendIfMissing(StrUtil.prependIfMissing(value,"\""),"\"");
        Long result = executeLua(key, value, LOCK_LUA, timeout, unit, Long.class);
        return SUCCESS.equals(result);
    }

    /**
     * 解锁
     *
     * @param key 锁的Key
     * @return boolean
     */
    public boolean unlock(String key) {
        return unlock(key, Constant.RESULT_1);
    }

    /**
     * 解锁
     *
     * @param key 锁的Key
     * @param value 锁的value，一定要跟加锁的value一致，否则会认为不是同一个锁，不会释放
     * @return boolean
     */
    public boolean unlock(String key, String value) {
        value = StrUtil.appendIfMissing(StrUtil.prependIfMissing(value,"\""),"\"");

        Long result = executeLua(key, value, UNLOCK_LUA,null, null, Long.class);

        return SUCCESS.equals(result);
    }

    /**
     * 获取等待锁，如果没有获取到锁就一直等待获取,直到超过waitTime的时间
     *
     * @param key 锁的key
     * @param timeout 锁的超时时间
     * @param unit 锁的超时时间单位
     * @param waitTime 获取锁时的等待时间,一直等不超时则填-1,单位：毫秒
     * @return java.lang.Boolean true为获取到锁,可以下一步业务, false为没有获取到锁
     */
    public Boolean setMutexWaitLock(String key, long timeout, TimeUnit unit, long waitTime) {
        long start = System.currentTimeMillis();
        while (true) {
            boolean result = setMutexLockAndExpire(key, timeout, unit);
            if (result) {
                return true;
            } else {
                long current = System.currentTimeMillis();
                // 超过等待时间还没获取到锁则返回false
                if (waitTime > 0 && (current - start > waitTime)) {
                    logger.warn("redis分布式锁获取失败，key[{}],等待时间[{}]", key, waitTime);
                    return false;
                }
                // 等待100毫秒后重试
                ThreadUtil.sleep(100);
            }
        }
    }

    public long getMutexLockExpireMinutes() {
        return MUTEX_EXPIRE_MINUTES;
    }

    /**
     * 获取自增序列号
     *
     * @param key 序列号的KEY
     * @param seq 自增值,默认自增1
     * @return java.lang.Long 自增后的值
     */
    public Long incr(String key, Long seq, long timeout, TimeUnit unit) {
        return executeLua(key, null, INCR_LUA, timeout, unit, Long.class);
    }

    /**
     * 执行LUA脚本
     *
     * @param key redisKey
     * @param value 值
     * @param lua lua脚本
     * @param timeout 超时时间
     * @param unit 超时单位
     * @param clazz 返回值类型
     * @return T 返回值
     */
    public <T> T executeLua(String key, Object value, String lua, Long timeout, TimeUnit unit, Class<T> clazz){
        // 有时间单位则转成秒，否则默认秒
        if (unit != null) {
            timeout = unit.toSeconds(timeout);
        }
        List<String> args = new ArrayList<>(2);
        if(value != null){
            args.add(Convert.toStr(value));
        }
        if(timeout != null){
            args.add(Convert.toStr(timeout));
        }
        //spring自带的执行脚本方法中，集群模式直接抛出不支持执行脚本异常，此处拿到原redis的connection执行脚本
        T result = (T)redisTemplate.execute(new RedisCallback<T>() {
            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                Object nativeConnection = connection.getNativeConnection();
                // 集群模式和单点模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行
                // 集群
                if (nativeConnection instanceof JedisCluster) {
                    return (T) ((JedisCluster) nativeConnection).eval(lua, Collections.singletonList(key), args);
                }

                // 单点
                else if (nativeConnection instanceof RedisProperties.Jedis) {
                    return (T) ((Jedis) nativeConnection).eval(lua, Collections.singletonList(key), args);
                }
                return null;
            }
        });
        return result;
    }



    public void expire(String key, long timeout, TimeUnit unit) {
        try {
            redisTemplate.expire(key, timeout, unit);
        } catch (Exception e) {
            logger.error("设置缓存过期时间失败,key={},timeout={},unit={}", key, timeout, unit, e);
        }
    }

    /**
     * 获取互斥线程等待时间
     *
     * @return
     */
    public long getMutexThreadWaitMilliseconds() {
        return MUTEX_WAIT_MILLISECONDS;
    }

    public Set<String> getKeys(String key) {
        return redisTemplate.keys(key);
    }

    /**
     * 获取随机秒数 如：getRandomTime(30, 7)返回30天到第37天的随机秒数，即时效时间最小为30天，最大为37天
     *
     * @param afterDays N天之后
     * @param rangeDay 日期范围
     * @return java.lang.Long 秒数
     */
    public static Long getRandomTime(int afterDays, int rangeDay) {
        Calendar calendar = Calendar.getInstance();
        long curTime = calendar.getTimeInMillis();
        calendar.add(Calendar.DAY_OF_MONTH, afterDays);
        long minTime = calendar.getTimeInMillis();
        calendar.add(Calendar.DAY_OF_MONTH, rangeDay);
        long maxTime = calendar.getTimeInMillis();
        long randomTime = RandomUtil.randomLong(minTime, maxTime);
        return (randomTime - curTime) / 1000;
    }

    /**
     * 获取30天内的随机秒数
     *
     * @return long 返回1天后30天内的随机秒数
     */
    public static long getRandomTime() {
        return getRandomTime(1, 30);
    }


    public void setnx(String key,String value){


    }


}

说说使用集群的情况。

redis的主从复制。

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(Master)，后者称为从节点(Slave)；数据的复制是单向的，只能由主节点到从节点。
默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。

redis哨兵模式。

哨兵(sentinel)：是一个分布式系统，用于对主从结构中的每台服务器进行监控，当出现故障时通过投票机制选择新的 Master 并将所有 Slave 连接到新的 Master。所以整个运行哨兵的集群的数量不得少于3个节点。

选三台redis搭建集群

添加springBootmaven依赖

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--连接池依赖-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!--web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>

集群yml文件配置

server:
  port: 3035
spring:
  redis:
    # redis哨兵配置
    sentinel:
      # 主节点名称
      master: mymaster
      nodes:
        - 192.168.200.150:6379
        - 192.168.200.150:6380
        - 192.168.200.150:6381
#    # 集群的部署方式
#    cluster:
#      nodes:
#        - 192.168.200.150:6379
#        - 192.168.200.150:6380
#        - 192.168.200.150:6381
#      # #最大重定向次数（由于集群中数据存储在多个节点,所以在访问数据时需要通过转发进行数据定位）
#      max-redirects: 2
#    lettuce:
#      pool:
#        max-idle: 10   # 连接池中的最大空闲连接
#        max-wait: 500   # 连接池最大阻塞等待时间（使用负值表示没有限制）
#        max-active: 8   # 连接池最大连接数（使用负值表示没有限制）
#        min-idle: 0   # 连接池中的最小空闲连接

  # 服务应用名
  application:
    name: redis-cluster
logging:
  pattern:
    console: '%date{yyyy-MM-dd HH:mm:ss.SSS} | %highlight(%5level) [%green(%16.16thread)] %clr(%-50.50logger{49}){cyan} %4line -| %highlight(%msg%n)'
  level:
    root: info
    io.lettuce.core: debug
    org.springframework.data.redis: debug

配置读写分离

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import io.lettuce.core.ReadFrom;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.text.SimpleDateFormat;
import java.util.HashSet;


@Configuration
public class RedisConfiguration {

    /**
     *
     *  配置redis序列化json
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    @Primary    //若有相同类型的Bean时，优先使用此注解标注的Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 为了开发方便,一般直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 配置具体的序列化方式
        // JSON解析任意对象
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域,field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        // 设置日期格式
        om.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String的序列化
        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;
    }

    /**
     * 配置读写分离
     * @param redisProperties
     * @return
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties) {
        // 配置哨兵节点以及主节点
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(
                redisProperties.getSentinel().getMaster(), new HashSet<>(redisProperties.getSentinel().getNodes())
        );

        // 配置读写分离
        LettucePoolingClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder()
                // 读写分离,这里的ReadFrom是配置Redis的读取策略,是一个枚举,包括下面选择
                // MASTER   仅读取主节点
                // MASTER_PREFERRED   优先读取主节点,如果主节点不可用,则读取从节点
                // REPLICA_PREFERRED   优先读取从节点,如果从节点不可用,则读取主节点
                // REPLICA   仅读取从节点
                // NEAREST   从最近节点读取
                // ANY   从任意一个从节点读取
                .readFrom(ReadFrom.REPLICA_PREFERRED)
                .build();

        return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration);
    }

}

再使用工具类操作就行。


package com.vinjcent.utils;

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

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

 
@Component
public final class RedisUtils {

    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * 可按自己需求生成"起始时间戳"
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;

    /**
     * 用于时间戳左移32位
     */
    public static final int MOVE_BITS = 32;

    @Autowired
    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    //=============================common===================================

    /**
     * 指定缓存失效时间
     * @param key   键
     * @param time  时间(秒)
     * @return  whether the key has expired
     */
    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;
        }
    }

    /**
     * 指定缓存失效时间(自定义时间单位)
     * @param key   键
     * @param time  时间(秒)
     * @return  whether the key has expired
     */
    public boolean expire(String key, long time, TimeUnit unit){
        try {
            if(time > 0){
                redisTemplate.expire(key, time, unit);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取过期时间(默认获取的是秒单位)
     * @param key   键(不能为null)
     * @return      the remaining time, "0" means never expire
     */
    public long getExpire(String key){
        Long time = redisTemplate.getExpire(key, TimeUnit.SECONDS);
        if (time != null) {
            return time;
        }
        return -1L;
    }

    /**
     * 根据key获取过期时间(自定义时间单位)
     * @param key   键(不能为null)
     * @return      the remaining time, "0" means never expire
     */
    public long getExpire(String key, TimeUnit unit){
        Long time = redisTemplate.getExpire(key, unit);
        if (time != null) {
            return time;
        }
        return -1L;
    }

    /**
     * 判断key是否存在
     * @param key   键
     * @return      whether the key exist
     */
    public boolean hasKey(String key) {
        Boolean flag = redisTemplate.hasKey(key);
        try {
            return Boolean.TRUE.equals(flag);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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


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

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


    /**
     * 普通缓存获取(泛型)
     * @param key   key键
     * @return      the value corresponding the key
     * @param targetType    目标类型
     * @param <T>           目标类型参数
     * @return      the generic value corresponding the key
     */
    public <T> T get(String key, Class<T> targetType){ return key == null ? null : JsonUtils.objParse(redisTemplate.opsForValue().get(key), targetType);}

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return      whether true or 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      whether true or 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 value 值
     * @param time  时间(秒) --- time要大于0,如果time小于0,将设置为无期限
     * @param timeUnit  时间单位
     * @return  whether true or false
     */
    public boolean set(String key, Object value, long time, TimeUnit timeUnit){
        try {
            if(time > 0){
                redisTemplate.opsForValue().set(key, value, time, timeUnit);
            }else {
                set(key,value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 递减
     * @param key   键
     * @param delta 要增加几(小于0)
     * @return      the value after decrement
     */
    public long decr(String key, long delta){
        if(delta < 0){
            throw new RuntimeException("递减因子必须大于0");
        }
        Long increment = redisTemplate.opsForValue().increment(key, delta);
        return increment != null ? increment : 0L;    }

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

    /**
     * 根据hashKey获取hash列表有多少元素
     * @param key   键(hashKey)
     * @return      the size of map
     */
    public long hsize(String key) {
        try {
            return redisTemplate.opsForHash().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * HashGet  根据"项 中的 键 获取列表"
     * @param key   键(hashKey)能为null
     * @param item  项不能为null
     * @return      the value of the corresponding key
     */
    public Object hget(String key, String item){ return redisTemplate.opsForHash().get(key, item);}

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

    /**
     * 获取HashKey对应的所有键值
     * @param key   键(hashKey)
     * @param keyType   键类型
     * @param valueType 值类型
     * @param <K>       键类型参数
     * @param <V>       值类型参数
     * @return      a map
     */
    public <K, V> Map<K, V> hmget(String key, Class<K> keyType, Class<V> valueType) {
        return JsonUtils.mapParse(redisTemplate.opsForHash().entries(key), keyType, valueType);}

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

    }

    /**
     * HashSet存入并设置时间
     * @param key   键(hashKey)
     * @param map   对应多个键值
     * @param time  时间(秒)
     * @return  whether true or 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   键(hashKey)
     * @param item  项
     * @param value 值
     * @return  whether true or 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   键(hashKey)
     * @param item  项
     * @param value 值
     * @param time  时间(秒)   注意: 如果已经在hash表有时间,这里将会替换所有的时间
     * @return  whether true or 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;
        }
    }

    /**
     * 放入map集合数据,如果不存在将创建
     * @param key   键(hashKey)
     * @param value map集合
     * @param <K>   map集合键参数类型
     * @param <V>   map集合值参数类型
     * @return  whether true or false
     */
    public <K, V> boolean hsetMap(String key, Map<K, V> value) {
        try {
            redisTemplate.opsForHash().putAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取key对应的所有map键值对
     * @param key   键(hashKey)
     * @return      the Map
     */
    public Map<Object, Object> hgetMap(String key) {
        try {
            return redisTemplate.opsForHash().entries(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取key对应的所有map键值对(泛型)
     * @param key   键(hashKey)
     * @param keyType   键类型
     * @param valueType 值类型
     * @param <K>       键类型参数
     * @param <V>       值类型参数
     * @return      the Map
     */
    public <K, V> Map<K, V> hgetMap(String key, Class<K> keyType, Class<V> valueType) {
        try {
            return JsonUtils.mapParse(redisTemplate.opsForHash().entries(key), keyType, valueType);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

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

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

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

    /**
     * hash递减
     * @param key   键(hashKey)
     * @param item  项
     * @param by    要减少几(小于0)
     * @return  the value of the corresponding key after decrement in one Map
     */
    public double hdecr(String key, String item, double by){
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //=============================Set===================================

    /**
     * 根据key获取Set中的所有值
     * @param key   键
     * @return      all values in one Set
     */
    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  whether true or false
     */
    public boolean sHasKey(String key, Object value){
        try {
            Boolean flag = redisTemplate.opsForSet().isMember(key, value);
            return Boolean.TRUE.equals(flag);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key       键
     * @param values    值
     * @return  the number of adding successfully
     */
    public long sSet(String key, Object... values){
        try {
            Long nums = redisTemplate.opsForSet().add(key, values);
            return nums != null ? nums : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 将set数据放入缓存,并设置有效时间
     * @param key       键
     * @param time      时间(秒)
     * @param values    值,可以是多个
     * @return  the number of adding successfully
     */
    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 != null ? count : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key   键
     * @return      the size of the Set
     */
    public long sGetSetSize(String key){
        try {
            Long size = redisTemplate.opsForSet().size(key);
            return size != null ? size : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 移除值为values的
     * @param key       键
     * @param values    值(可以是多个)
     * @return          the number of removal
     */
    public long setRemove(String key, Object... values){
        try {
            Long nums = redisTemplate.opsForSet().remove(key, values);
            return nums != null ? nums : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    //=============================List===================================

    /**
     * 获取list列表数据
     * @param key       键
     * @return          all values of one List
     */
    public List<Object> lget(String key) {
        try {
            return redisTemplate.opsForList().range(key, 0, -1);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     /**
     * 获取list列表数据(泛型)
     * @param key       键
     * @param targetType    目标类型
     * @param <T>           目标类型参数
     * @return      all values of one List
     */
    public <T> List<T> lget(String key, Class<T> targetType) {
        try {
            return JsonUtils.listParse(redisTemplate.opsForList().range(key, 0, -1), targetType);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key   键
     * @return      the length of the List
     */
    public long lGetListSize(String key){
        try {
            Long size = redisTemplate.opsForList().size(key);
            return size != null ? size : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 通过索引获取list中的值
     * @param key   键
     * @param index 索引 index >= 0 时, 0:表头, 1:第二个元素,以此类推...    index < 0 时, -1:表尾, -2:倒数第二个元素,以此类推
     * @return  the value of the specified index in one List
     */
    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 index 索引 index >= 0 时, 0:表头, 1:第二个元素,以此类推...    index < 0 时, -1:表尾, -2:倒数第二个元素,以此类推
     * @return  the value of the specified index in one List
     * @param targetType    目标类型
     * @param <T>           目标类型参数
     * @return  the generic value of the specified index in one List
     */
    public <T> T lgetIndex(String key, long index, Class<T> targetType) {
        try {
            return JsonUtils.objParse(redisTemplate.opsForList().index(key, index), targetType);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @return  whether true or false
     */
    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  时间(秒)
     * @return  whether true or false
     */
    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 values    值
     * @return  whether true or false
     */
    public <T> boolean lSet(String key, List<T> values){
        try {
            Long nums = redisTemplate.opsForList().rightPushAll(key, values);
            return nums != null;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 根据索引修改list中的某条数据
     * @param key   键
     * @param value 值
     * @param index 索引
     * @return  whether true or false
     */
    public boolean lUpdateIndex(String key, Object value, long index){
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key       键
     * @param value     值
     * @param number    移除多少个
     * @return          返回移除的个数
     */
    public long lRemove(String key, Object value, long number){
        try {
            Long count = redisTemplate.opsForList().remove(key, number, value);
            return count != null ? count : 0L;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    //=============================Lock===================================

    /**
     * 解决缓存加锁问题
     * @param key   锁名称
     * @param value 锁值
     * @param timeout   超时时间
     * @param unit  时间单位
     * @param <T>   锁值的数据类型
     * @return  返回加锁成功状态
     */
    public <T> boolean tryLock(String key, T value, long timeout, TimeUnit unit) {
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
        return Boolean.TRUE.equals(flag);
    }

    /**
     * 解决缓存解锁操作
     * @param key   锁名称
     * @return  返回解锁成功状态
     */
    public boolean unLock(String key) {
        Boolean flag = redisTemplate.delete(key);
        return Boolean.TRUE.equals(flag);
    }

    /**
     * 全局生成唯一ID策略
     * 设计: 符号位(1位) - 时间戳(32位) - 序列号(31位)
     * @param keyPrefix     key的前缀
     * @return  返回唯一ID
     */
    public long globalUniqueKey(String keyPrefix) {

        // 1. 生成时间戳
        LocalDateTime now = LocalDateTime.now();

        // 东八区时间
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        // 相减获取时间戳
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2. 生成序列号(使用日期作为redis自增长超2^64限制,灵活使用年、月、日来存储)
        // 获取当天日期
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 自增长
        Long increment = redisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
        long count = increment != null ? increment : 0L;

        // 3. 拼接并返回(使用二进制或运算)
        return timestamp << MOVE_BITS | count;
    }

}

Redis主从设计是一种数据架构方案，通过在多个Redis服务器之间实现数据同步，以提高系统的可扩展性和可靠性。以下是关于Redis主从设计的详细介绍：

一、主从复制原理

在Redis主从复制架构中，一个或多个Redis服务器充当从节点，复制主节点的数据。当主节点接收到客户端的写操作请求时，它会将数据变更事件记录到内存中的日志中。从节点通过监听主节点的日志，可以实时获取数据变更事件并更新自己的数据集。这样，从节点就可以保持与主节点同步的状态。

二、主从复制过程

  1. 主节点将数据变更事件记录到二进制日志中。
  2. 从节点连接到主节点，并读取主节点记录的日志。
  3. 从节点根据日志中的数据变更事件，更新自己的数据集。
  4. 通过这种方式，从节点就可以保持与主节点同步的状态。

三、Redis主从复制的优势

  1. 读写分离：主从复制可以实现读写分离，将读请求分散到多个从节点上，减轻主节点的负载，提高系统的吞吐量。
  2. 故障恢复：当主节点出现故障时，可以将一个从节点提升为主节点，保证系统的可用性。同时，其他从节点仍然可以提供读服务。
  3. 扩展性：通过增加更多的从节点，可以水平扩展Redis服务的读请求处理能力。

四、配置Redis主从复制

  1. 修改配置文件：在每个Redis服务器的配置文件中，需要设置相应的主从配置项。例如，在主节点的配置文件中添加以下内容：

 

makefile复制代码
 

bind 127.0.0.1 6379 
masterof yes
 

在从节点的配置文件中添加以下内容：
 

 

makefile复制代码
 

bind 127.0.0.1 6380 
masterof yes
 

  1.  
    重启Redis服务：修改配置文件后，需要重启Redis服务以使配置生效。可以使用以下命令重启Redis服务：
     
 

 

shell复制代码
 

redis-cli -p 6379 shutdown 
redis-cli -p 6380 shutdown
 

然后重新启动Redis服务：
 

 

shell复制代码
 

redis-cli -p 6379 start 
redis-cli -p 6380 start
 

  1.  
    验证主从复制：可以使用以下命令检查主从复制是否正常工作：
     
 

 

shell复制代码
 

redis-cli -p 6379 info replication 
redis-cli -p 6380 info replication
 

如果返回结果中的role字段显示为master和slave，则表示主从复制正常工作。
 4. 设置密码保护：为了保护Redis服务器的安全，建议为Redis设置密码保护。可以使用以下命令设置密码：
 

在主节点上执行以下命令：
 

 

shell复制代码
 

redis-cli -p 6379 config set requirepass yourpassword123456!
 

在从节点上执行以下命令：
 5. 设置密码保护：为了保护Redis服务器的安全，建议为Redis设置密码保护。可以使用以下命令设置密码：在主节点上执行以下命令：redis-cli -p 6379 config set requirepass yourpassword123456!在从节点上执行以下命令：redis-cli -p 6380 config set requirepass yourpassword123456!通过设置密码保护，可以防止未经授权的访问和操作。注意替换yourpassword123456!为实际的密码。6. 数据同步：如果之前已经有一些数据存在于主节点上，从节点需要将数据进行同步。可以使用以下命令手动同步数据：在从节点上执行以下命令：redis-cli -p 6380 slaveof <masterip> <masterport>将<masterip>和<masterport>替换为主节点的IP地址和端口号。这将使从节点开始同步主节点的数据。注意，手动同步数据可能会导致数据丢失或不一致，因此建议在同步之前备份数据。7. 数据迁移和故障转移：如果需要将一个从节点提升为主节点或进行其他数据迁移操作，可以使用Redis提供的工具进行操作。例如，可以使用redis-trib工具进行数据迁移和故障转移等操作。需要注意的是，在进行数据迁移和故障转移操作时，需要谨慎操作并确保数据的完整性和一致性。综上所述，通过合理配置Redis主从复制架构，可以提高系统的可扩展性和可靠性。在实际应用中，需要根据具体需求进行配置和优化，并注意安全性和数据一致性的问题。

                

        

        

        

    




    

      

        

            

              
                
                  奋力向前123
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    43
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    55
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  31
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java连接redis

				
			

			

				

					2301_76898372的博客
				

				

					04-26
					
					864
					
				

			

		

		

			
				
它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。上面的连接都是连接的单机版的redis,真实项目它们的redis都是集群模式。map.put("name","刘民证");map.put("sex","女");第一种:jedis---传统的项目--ssm。//value hashmap序列化。

			
		

	



                

              
                



	

		

			

				
					
深入学习 Redis - 基于 Jedis 通过 Java 客户端操作 Redis 和 Redis 集群

				
			

			

				

					CYK_byte的博客
				

				

					07-30
					
					778
					
				

			

		

		

			
				
我们在本地 windows 主机上，使用 xshell 连接远程服务器，主要就是通过 ssh 协议（默认走 22 端口）实现通信的，他有一个很重要的特性，就是支持端口转发！我们只需要配置 ssh 程序监听本地端口，映射到云服务器的端口，就可以实现通过 windows 主机，访问云服务器的 6379 端口.Ps：一个优秀的库，一定是非常容易上手的，因此接下来介绍的操作，不会覆盖到所有指令，会挑选出一些重要 / 代表性的命令，来进行演示~Ps：当配置了端口准发后，一定要断开之前的连接，重新连接才能生效.

			
		

	



                


  
              

                


	

		

			

				
					
面试八股之Redis篇3.1——集群——Redis集群有哪些方案, 知道嘛 ?

					
最新发布

				
			

			

				

					做一个善良的人，做好自己的事，如果愿意，再发一份光。
				

				

					05-31
					
					750
					
				

			

		

		

			
				
🔥本篇概览：详细讲解了Redis集群的方案

			
		

	





	

		

			

				
					
spring boot连接Redis集群

				
			

			

				

					weixin_41363927的博客
				

				

					04-22
					
					3440
					
				

			

		

		

			
				
spring boot连接Redis集群
一、导入POM.XML
SpringBoot2.0 Redis相关Jar包
  <!--默认是lettuce客户端-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifact

			
		

	



		

			
		



	

		

			

				
					
java 分布式缓存 redis持久化 redis主从 Redis哨兵 Redis分片集群

				
			

			

				

					m0_73859807的博客
				

				

					02-02
					
					443
					
				

			

		

		

			
				
- 基于Redis集群解决单机Redis存在的问题单机的Redis存在四大问题：数据丢失问题 ：Redis是内存存储，服务重启可能会丢失数据并发能力问题 ：单节点Redis并发能力虽然不错，但也无法满足如618这样的高并发场景故障恢复问题 ：如果Redis宕机，则服务不可用，需要一种自动的故障恢复手段存储能力问题 ：Redis基于内存，单节点能存储的数据量难以满足海量数据需求。

			
		

	





	

		

			

				
					
详解Redis的主从同步原理

				
			

			

				

					Java技术攻略的博客
				

				

					03-07
					
					1055
					
				

			

		

		

			
				
Redis为了保证服务高可用，其中一种实现就是主从模式，即一个Redis服务端作为主节点，若干个Redis服务端作为主节点的从节点，从而实现即使某个服务端不可用时，也不会影响Redis服务的正常使用。本篇文章将对主从模式中为了保证主节点和从节点数据一致而实现的主从同步机制进行学习。Redis主从模式中，一个高可用的Redis服务由一个Redis主节点（Master，后续简称为主节点）和若干Redis从节点（Slave，后续简称为从节点）组成。Redis中采用读写分离。

			
		

	





	

		

			

				
					
redis主从复制集群

				
			

			

				

					08-11
				

			

		

		

			
				
实现了redis主从复制（读写分离）集群

			
		

	





	

		

			

				
					
Redis部署笔记（单机+主从+哨兵+集群）

				
			

			

				

					09-14
				

			

		

		

			
				
基于Centos7系统，由浅入深讲解如何部署Redis的四种模式，分别是：单机模式、主从模式、哨兵模式、集群模式。 完整原文：http://exp-blog.com/2018/09/14/pid-2285/  同时提供Jedis客户端封装源码： ● 屏蔽Jedis与...

			
		

	





	

		

			

				
					
2、redis主从复制以及密码、配置文件启动1

				
			

			

				

					08-08
				

			

		

		

			
				
在本例中，我们将探讨如何设置Redis主从复制，配置密码保护，通过配置文件启动Redis，并引入Sentinel哨兵系统来实现故障切换。  首先，我们需要准备至少三个Redis实例，一个作为主节点（master），两个作为从节点...

			
		

	





	

		

			

				
					
Redis集群配置文件

				
			

			

				

					05-23
				

			

		

		

			
				
Redis的集群配置文件，有关Redis的集群搭建详情请参见博文：http://blog.csdn.net/l1028386804/article/details/72633608

			
		

	





	

		

			

				
					
java客户端测试redis集群

				
			

			

				

					11-13
				

			

		

		

			
				
此是Java程序，用来测试redis集群.................................................

			
		

	





	

		

			

				
					
【Redis缓存机制】14.Java连接Redis_Jedis_主从模式

				
			

			

				

					程序猿之洞
				

				

					12-16
					
					7682
					
				

			

		

		

			
				
redis的主从模式之前提到过，这里我们使用redis来实现主从模式。

首先在VMware虚拟机中的Linux中打开两个终端，一个是用户jack，一个是newuser:


然后我们jack作为主机，redis服务运行在6379端口，我们设置newuser为从机，设置其redis
运行在6380端口，然后使用slaveof no one清除两机的所有主从关系:

注意:我们客户端

			
		

	





	

		

			

				
					
使用Java连接到Redis

				
			

			

				

					大力海棠的博客
				

				

					07-12
					
					1861
					
				

			

		

		

			
				
目录

连接Redis服务器

Jedis使用管道

运行Lua脚本

使用连接池

  使用Java连接Redis，需要使用Redis的Java客户端（Jedis）才能在Java应用程序中使用Redis，当然我们也可以用IDEA或其他IDE，这篇日志就来总结下Java连接Redis的一些操作。需要安装JDK1.8还有Jedis的JAR包，并把它们配置到CLASSPATH里，当然也可以用Maven来帮我们构建管理这些依赖，如果我们使用Gradle来管理Jedis的依赖项的话，需要将这一行内容

comp..

			
		

	





	

		

			

				
					
Redis（九） 用java操作集群

				
			

			

				

					weixin_43189971的博客
				

				

					08-09
					
					264
					
				

			

		

		

			
				
无

			
		

	





	

		

			

				
					
【Java进阶营】Redis 集群★★★

				
			

			

				

					Netty711的博客
				

				

					05-01
					
					1602
					
				

			

		

		

			
				
目录
1、搭建
2、故障恢复
3、jredis开发
阿K须知点：
操作集群的添加，查询（对应的插槽机），查看节点（cluseer nodes）都必须在主机上面操作。
一、搭建
1、解决两个问题
（1）容量不够，redis如何进行扩容？
（2）并发写操作， redis如何分摊？
另外，主从模式，薪火相传模式，主机宕机，导致ip地址发生变化，应用程序中配置需要修改对应的主机地址、端口等信息。
之前通过代理主机来解决，但是redis3.0中提供了解决方案。就是无中心化集群配置
2、什么是集群
（1）Redis 集

			
		

	





	

		

			

				
					
redis主从 java_Redis主从复制

				
			

			

				

					weixin_39624071的博客
				

				

					02-15
					
					107
					
				

			

		

		

			
				
主从复制a,方式一、新增redis6380.conf, 加入 slaveof 192.168.1.111 6379, 在6379启动完后再启6380，完成配置；b,方式二、redis-server --slaveof 192.168.1.111 6379c,查看状态：info replicationd,断开主从复制：在slave节点，执行6380:>slaveof no onee,断开后...

			
		

	





	

		

			

				
					
java 培训 redis 的集群策略

				
			

			

				

					m0_70565884的博客
				

				

					05-25
					
					455
					
				

			

		

		

			
				
redis

redis 是单线程的，但是一般的作为缓存使用的话，redis 足够了，因为它的读写速度太快了。官方的一个简单测试：测试完成了 50 个并发执行 100000 个请求。设置和获取的值是一个 256 字节字符串。结果:读的速度是 110000 次/s,写的速度是 81000 次/s 但对于访问量特别大的服务来说，还是稍有不足。那么，如何提升 redis 的性能呢？搭建集群。

redis 主要提供三种集群策略：


	主从复制
	
	
	集群
	
	
	哨兵
	
一、主从复制

在主从复制中，数

			
		

	





	

		

			

				
					
spring redis 主从集群配置

				
			

			

				

					11-17
				

			

		

		

			
				
以下是Spring Boot集成Redis主从集群的配置方法：

1.在pom.xml文件中添加以下依赖：

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

2.在application.properties文件中添加以下配置：

```properties
# Redis主节点配置
spring.redis.master.host=127.0.0.1
spring.redis.master.port=6379
spring.redis.master.password=123456

# Redis从节点配置
spring.redis.slave.nodes=127.0.0.1:6380,127.0.0.1:6381
spring.redis.slave.password=123456
```

3.创建RedisConfig类，配置RedisTemplate和JedisConnectionFactory：

```java
@Configuration
public class RedisConfig {

    @Value("${spring.redis.master.host}")
    private String masterHost;

    @Value("${spring.redis.master.port}")
    private int masterPort;

    @Value("${spring.redis.master.password}")
    private String masterPassword;

    @Value("${spring.redis.slave.nodes}")
    private String slaveNodes;

    @Value("${spring.redis.slave.password}")
    private String slavePassword;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("127.0.0.1", 26379)
                .sentinel("127.0.0.1", 26380)
                .sentinel("127.0.0.1", 26381)
                .setPassword(masterPassword);
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig);
        jedisConnectionFactory.setUsePool(true);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        return jedisConnectionFactory;
    }

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(100);
        jedisPoolConfig.setMaxIdle(50);
        jedisPoolConfig.setMinIdle(20);
        jedisPoolConfig.setMaxWaitMillis(3000);
        return jedisPoolConfig;
    }
}
```

4.在需要使用Redis的类中注入RedisTemplate即可使用。



			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 31

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
奋力向前123

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值