springboot集成redis：整合单节点redis、发布订阅、哨兵-主备读写分离、集群

已于 2023-05-11 14:31:23 修改
阅读量1.3k 收藏 5
点赞数 1
分类专栏： springboot 文章标签： spring boot redis java
于 2023-05-11 14:05:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/microhoo_/article/details/130618366
版权
文章详细介绍了如何在SpringBoot项目中整合单节点Redis，包括添加依赖、配置YML、创建配置类和工具类，以及发布与订阅功能的实现。接着，文章讲述了如何配置哨兵系统以实现主备读写分离，最后讨论了Redis集群的配置和使用。每个部分都包含了具体的代码示例和步骤说明。
摘要由CSDN通过智能技术生成

目录

一、springboot整合单节点redis

1、添加依赖

2、添加配置application.yml配置

3、添加配置类

4、工具类

5、发布与订阅

5.1 添加配置对象

5.2 定义消息接收类

5.3 使用：在redisUtils工具类中添加发布消息的方法

5.4 发布消息

二、哨兵-主备读写分离

1.添加依赖

2、配置yml

3、添加配置文件

4、工具类同上

三、集群

1、添加Spring Boot和Redis依赖

2、修改配置文件

3、配置类(创建RedisTemplate实例)

4、工具类同上

5、使用postman调接口测试Redis集群

一、springboot整合单节点redis

1、添加依赖

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

2、添加配置application.yml配置

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password: 
    lettuce:
      pool:
         # 连接池中的最大空闲连接 默认8      
        max-idle: 8
        # 连接池中的最小空闲连接 默认0
        min-idle: 0
        # 连接池最大连接数 默认8 ，负数表示没有限制
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
        max-wait: -1
    timeout: 30000

3、添加配置类

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.Resource;

/**
 * @Description: redis配置类
 */
@Configuration
public class RedisConfiguration {

    @Resource
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate= new RedisTemplate<>();
        // 可根据需要添加序列化器
        // template.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

}

4、工具类

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


/**
 * Redis工具类
 */

@Component
@Log4j2
public final class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    public Map<String, Object> obtainMap(String jsonString) {
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> map = null;
        try {
            map = mapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }


    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    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 Boolean.TRUE.equals(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((Collection<String>) 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)
     * @return
     */
    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)
     * @return
     */
    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
     * @return 值
     */
    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 对应多个键值
     * @return true 成功 false 失败
     */
    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)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    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 键
     * @return
     */
    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;
        }
    }
    //==============================zset===================================

    /**
     * 添加一个元素到排序集合
     *
     * @param key 键
     * @param value 值
     * @param score 分数
     * @return 是否成功添加
     */
    public Boolean zAdd(String key, Object value, double score) {
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.add(key, value, score);
    }

    /**
     * 获取排序集合指定排名范围内的元素
     *
     * @param key 键
     * @param start 起始排名（从0开始）
     * @param end 终止排名（从0开始）
     * @return 排序集合指定排名范围内的元素
     */
    public Set<Object> zRange(String key, long start, long end) {
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.range(key, start, end);
    }

    /**
     * 获取排序集合指定分数范围内的元素
     *
     * @param key 键
     * @param minScore 最小分数
     * @param maxScore 最大分数
     * @return 排序集合指定分数范围内的元素
     */
    public Set<Object> zRangeByScore(String key, double minScore, double maxScore) {
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.rangeByScore(key, minScore, maxScore);
    }

    /**
     * 获取排序集合元素个数
     *
     * @param key 键
     * @return 排序集合元素个数
     */
    public Long zSize(String key) {
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.size(key);
    }

    /**
     * 获取排序集合指定元素的分数
     *
     * @param key 键
     * @param value 值
     * @return 排序集合指定元素的分数
     */
    public Double zScore(String key, Object value) {
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.score(key, value);
    }

    /**
     * 删除排序集合指定元素
     *
     * @param key 键
     * @param values 待删除的元素
     * @return 删除的元素个数
     */
    public Long zRemove(String key, Object... values) {
        ZSetOperations<String,Object> zSetOperations = redisTemplate.opsForZSet();
        return zSetOperations.remove(key, values);
    }


    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    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 键
     * @return
     */
    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倒数第二个元素，依次类推
     * @return
     */
    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 值
     * @return
     */
    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
     */
    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;
        }
    }


}

5、发布与订阅

5.1 添加配置对象

/**
     * 消息监听
     * <p>
     * 可以传入多个 MessageListenerAdapter
     */
    @Bean
    RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory, MessageListenerAdapter messageListenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        // 监听所有库的key过期事件
        container.setConnectionFactory(connectionFactory);
        // 可以添加多个 messageListener，配置不同的通道
        container.addMessageListener(messageListenerAdapter, new PatternTopic("user"));
        return container;
    }
    /**
     * 消息监听器适配器，绑定消息处理器
     * <p>
     * 可以配置多个 listenerAdapter，监听不同的通道
     */
    @Bean
    MessageListenerAdapter listenerAdapter(RedisMessageListener receiver) {
        return new MessageListenerAdapter(receiver, "onMessage");
    }

其中的new PatternTopic("user")中的 user 就是通道名。

5.2 定义消息接收类

/**
 * Redis 消息接收
 *
 * @Author Lizhou
 **/
@Slf4j
@Component
public class RedisMessageListener implements MessageListener {

    @Override
    public void onMessage(Message message, byte[] pattern) {
        // 接收的topic
        log.info("channel:" + new String(pattern));
        // 消息的POJO
        log.info("message:" + message.toString());
    }
}

5.3 使用：在redisUtils工具类中添加发布消息的方法

 /**
     * 向通道发布消息
     */
    public boolean convertAndSend(String channel, Object message) {
        if (StringUtils.isEmpty(channel)) {
            return false;
        }
        try {
            redisTemplate.convertAndSend(channel, message);
//            log.info("发送消息成功，channel：{}，message：{}", channel, message);
            return true;
        } catch (Exception e) {
//            log.info("发送消息失败，channel：{}，message：{}", channel, message);
            e.printStackTrace();
        }
        return false;
    }

5.4 发布消息

public void get1(){
   String message = "Hello World!";
   // 发送消息
   redisUtils.convertAndSend("user", message);
}
只要发布消息到通道中，有监听器的存在，就会跑到消息接收类RedisMessageListener的onMessage方法中。

二、哨兵-主备读写分离

1.添加依赖

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

2、配置yml

spring:
  redis:
    client-type: LETTUCE
    sentinel:
      master: mymaster
      nodes: 192.168.109.134:26380,192.168.109.134:26381,192.168.109.134:26382
      password:

3、添加配置文件

@Configuration
public class RedisConfig {

    @Autowired
    private Environment environmet;

    @Bean("lettuceConnectionFactory")
    public RedisConnectionFactory lettuceConnectionFactory() {
        String master = environmet.getProperty("spring.redis.sentinel.master");
        Set<String> nodes = StringUtils.commaDelimitedListToSet(environmet.getProperty("spring.redis.sentinel.nodes"));
        String password = environmet.getProperty("spring.redis.sentinel.password");

        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration(master, nodes);
        sentinelConfig.setPassword(RedisPassword.of(password));
        return new LettuceConnectionFactory(sentinelConfig);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(@Qualifier("lettuceConnectionFactory") RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
    
}

4、工具类同上

三、集群

1、添加Spring Boot和Redis依赖

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

2、修改配置文件

spring:
  redis:
    database: 0
    cluster:
      nodes: 192.168.177.128:6379,192.168.177.128:6380,192.168.177.128:6381,192.168.177.128:6382,192.168.177.128:6383,192.168.177.128:6384
    password:
    lettuce:
      pool:
        # 连接池中的最大空闲连接 默认8
        max-idle: 8
        # 连接池中的最小空闲连接 默认0
        min-idle: 0
        # 连接池最大连接数 默认8 ，负数表示没有限制
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
        max-wait: -1
    timeout: 30000

3、配置类(创建RedisTemplate实例)

@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate= new RedisTemplate<>();
        // 可根据需要添加序列化器
        // template.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return template;
    }

}

4、工具类同上

5、使用postman调接口测试Redis集群

@Slf4j
@RestController
public class TestController {

    @Resource
    private RedisUtil redisUtil;

    @GetMapping("/set")
    public String set(){
        redisUtil.set("key1", "value");
        return "success";
    }

    @GetMapping("/get")
    public String get(){
        Object result = redisUtil.get("key1");
        return result.toString();
    }

}

【微服务】springboot整合redis哨兵集群使用详解
congge
08-02 5489
springboot整合redis哨兵集群使用详解
Spring Boot整合Redis实现发布-订阅
OyLinux的博客
10-05 267
通过创建发布者和订阅者类，配置Redis消息监听器，并使用RedisTemplate来发布消息，我们能够实现消息的发布和订阅功能。在Spring Boot中，我们可以使用Redis来实现发布-订阅模式，通过Redis的消息队列功能，实现消息的发布和订阅。在这个例子中，我们创建了一个名为MessageController的REST控制器，并注入了之前创建的发布者对象。接下来，我们可以在需要的地方使用发布者来发布消息，并让订阅者监听消息。在这个配置类中，我们注入了之前创建的订阅者对象，并通过。
Springboot集成Redis
12-21
文章目录引入pom依赖配置redis引入RedisTemplate模板对redis操作编写一个测试类乱码分析及解决 引入pom依赖 org.springframework.boot spring-boot-starter-data-redis 2.2.6.RELEASE 配置redis 端口和ip地址,默认的是6379和127.0.0.1,一般不需要配置,如果远程操作则把ip地址修改一下即可 spring.redis.host=127.0.0.1 spring.redis.port=6379
springboot配置redis
dianjiang0725的博客
10-31 163
1、引入 spring-boot-starter-redis(1.4版本前)，spring-boot-starter-data-redis（1.4版本后） <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sprin...
SpringBoot整合redis集群和redis单节点
zhanghe687的博客
10-25 910
【代码】SpringBoot整合redis集群和redis单节点。
[springboot]整合连接redis单例、哨兵及集群模式
最新发布
2401_85117779的博客
06-20 276
最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。
[C1进阶之路-Web基础] CSS背景属性_div需要设置背景图001
2401_84538544的博客
04-21 268
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节。
SpringBoot使用Redis 数据访问(单点、集群、哨兵、连接池、Pipline、分布式框架Redisson、解决方案)
纸上得来终觉浅，绝知此事要躬行
04-29 2229
Redis操作是单线程的，使用连接池可以减少连接的创建，redis连接池有两种方式:Jedis(JedisPool) 和 Lettuce(LettucePool)。Lettuce 和 Jedis 的定位都是Redis的client，所以他们当然可以直接连接redis server。在Lettuce和Jedis之外还有Redission ，Redisson：实现了分布式和可扩展的Java数据结构。...
Redis集群-Redis安装、Redis主从复制、哨兵、Redis集群
12-25
Redis集群是Redis的一种高可用性解决方案，它可以将多个Redis节点组成一个集群，每个节点都可以保存整个集群中的所有数据。集群可以实现横向扩展，提高系统的可用性和可扩展性。 在配置集群时，我们需要设置不同的...
SpringBoot整合redis集群实现读写分离（哨兵模式）
wy971744839的博客
08-05 4578
服务都运行在我们虚拟机上，我这里的设置的IP地址都为192.168.159.100（根据自己的IP地址定义），端口分别为6380、6381、6382，以6380作为主节点，6381、6382作为从节点。配置文件可在解压后的源码文件根目录中找到，这里以从节点 6381 配置文件为例，其余两个配置文件几乎一致。在整合springboot之前，首先要开放redis集群的防火墙端口，不然连接不上我们的redis服务。服务，分别运行于26380、26381、26382三个端口，同样也需要配置.conf文件运行服务。
Linux中使用redis（七）SpringBoot整合redis
m0_65992672的博客
04-27 342
Linux中使用redis（七）SpringBoot整合redis，哨兵，集群
第 1 篇 : SpringBoot整合Redis单节点
qiezi__的博客
11-05 793
1. 新建SpringBoot项目 1.1 打开 setting ,配置Maven 1.2 打开pom文件,修改版本为 2.3.4.RELEASE ,刷新maven 1.3 新增Swagger3.0依赖,刷新maven <!-- Swagger3.0 --> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-boot-starter</ar
springboot集成redis哨兵集群
Mr. Wu's blog
09-26 5003
springboot集成redis哨兵集群
Springboot集成整合Redis-哨兵集群（4）
若成风的博客
09-01 403
Springboot集成整合Redis代码-哨兵集群
spring集成redis单节点、集群、哨兵配置
07-09
Redis 是一个开源的 key-value 存储系统，由于出众的性能，大部分互联网企业都用来做服务器端缓存。Redis 支持单实例模式，集群主从模式、哨兵模式等部署
Springboot集成Redis的哨兵集群(实现读写分离)
weixin_71901717的博客
04-22 1106
Springboot项目怎么连接Redis哨兵集群,实现Redis的读写分离功能
SpringBoot+Redis哨兵模式
wl_Honest的博客
04-14 8654
最近学习到了Redis的哨兵模式，光看视频还不行，需要自己动手实现一遍才能加深映像，特此记录。 由于没有真实的服务器可以供我操作，所以在虚拟机上启动了3个redis服务，分别占用7001、7002、7003端口。 Redis下载安装不多赘述，只在这里记录一下配置。 首先在tmp目录下创建3个文件夹: cd /tmp mkdir 7001 7002 7003 然后将redis的配置文件redis.conf拷贝到刚刚创建的3个文件夹下 cp redis-6.2.6/redis.conf
Spring Boot整合Redis实现发布/订阅功能
热门推荐
傲泣龙腾的博客
06-10 1万+
Redis作为一个高性能的内存数据存储，除了支持缓存和持久化数据，它还有很多功能，如：在博主分享的上一篇文章中，我们介绍了使用Redis实现的延迟队列功能【Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟队列】发布/订阅（Pub/Sub）发布/订阅是一种消息通信模式，其中发送者（发布者）发布消息，多个接收者（订阅者）订阅并接收这些消息。发布者和订阅者之间没有直接联系，消息由消息中间件（如Redis）传递。通过本文，我们详细介绍了如何在中整合Redis。
spring集成redis(单节点)
weixin_42231507的博客
06-23 669
redis是一种非关系型数据库，与mongoDB不同的是redis是内存数据库，所以访问速度很快。常用作缓存和发布-订阅式的消息队列。redis官方没有提供windows版本的软件。windows版本一直是微软维护的。下载地址：https://github.com/MSOpenTech/redis/releases。这里是redis相关的教程。http://muxiulin.cn/archives...
SpringBoot整合redis（redis支持单节点和集群）
嘉禾嘉宁papa
07-14 8460
一、简介 二、Maven依赖 三、RedisAutoConfiguration源码 四、自定义RedisConfig配置（核心） 4.1 配置源代码 4.2 单节点配置 4.2 集群节点配置 五、实践 5.1、测试源代码 5.2、测试结果 5.3、redis中Java 8值的序列化效果图 结语
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值