springboot2.X 配置Jedis集群和单机版(基于代码配置)

最新推荐文章于 2025-04-06 00:18:03 发布
最新推荐文章于 2025-04-06 00:18:03 发布
阅读量1.2k 收藏 9
点赞数 2
分类专栏： java redis redistemplate 文章标签： 配置 springboot redis springboot2.X
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_37709455/article/details/90812316
版权

springboot2.X 集成Jedis配置-基于代码配置

目录

基于springboot 2.1.5.RELEASE，springboot2.X默认redis客户端是lettuce。本文使用的是jedis配置（建议使用lettuce）

  • jedis 轻量级 线程不安全,可以通过线程池解决安全问题
  • lettuce 基于netty实现的线程安全客户端
  • redission 分布式客户端,支持分布式的操作

引入maven

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>

        <!--加载yml配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

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

properties单机版

  • 单机版
/**
 * 单机版properties
 * @author warApe
 * @date 2018/5/14 14:25
 */
@Data
public class JedisClientPoolProperties {

    private int maxTotal;
    private int maxIdle;
    private int maxWaitMillis;
}

/**
 * @author warApe
 * @date 2018/5/14 14:23
 */
@Data
public class JedisClientProperties {

    private int port;
    private String hostName;
    private int connectTimeout;
    private int readTimeout;

}

BeanConfig 单机版

/**
 * @program: springboot-share
 * @description: bean加载config
 * @author: warApe
 * @create: 2019-05-31 14:58
 **/
@Configuration
public class BeanConfig {

    @Bean
    @ConfigurationProperties(prefix = "com.warape.redis.standalone.pool")
    public JedisClientPoolProperties jedisClientPoolProperties() {
        return new JedisClientPoolProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "com.warape.redis.standalone.client")
    public JedisClientProperties jedisClientProperties() {
        return new JedisClientProperties();
    }
}

JedisClientConfig 配置 单机版

/**
 * redis单机版配置
 *
 * @author warApe
 * @date 2018/5/11 15:50
 * @see SpringbootShareApplication
 */
//@Profile("local")//指定运行环境
@Configuration
public class JedisClientConfig extends RedisAutoConfiguration {

    private JedisClientPoolProperties jedisClientPoolProperties;
    private JedisClientProperties jedisClientProperties;

    @Autowired
    public JedisClientConfig(JedisClientPoolProperties jedisClientPoolProperties, JedisClientProperties jedisClientProperties) {
        this.jedisClientPoolProperties = jedisClientPoolProperties;
        this.jedisClientProperties = jedisClientProperties;
    }

    /**
     * 单节点
     *
     * @return
     */
    @Bean
    public RedisConnectionFactory defaultJedisConnectionFactory() {
        //如果什么参数都不设置，默认连接本地6379端口
        RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
        standaloneConfiguration.setHostName(jedisClientProperties.getHostName());
        standaloneConfiguration.setPort(jedisClientProperties.getPort());


        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        //最大空闲
        genericObjectPoolConfig.setMaxIdle(jedisClientPoolProperties.getMaxIdle());
        //链接池中最大连接数
        genericObjectPoolConfig.setMaxTotal(jedisClientPoolProperties.getMaxTotal());
        //最小空闲
        genericObjectPoolConfig.setMinIdle(jedisClientPoolProperties.getMaxIdle());
        //连接池资源耗尽后  最大等待时间
        genericObjectPoolConfig.setMaxWaitMillis(jedisClientPoolProperties.getMaxWaitMillis());

        JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder()
                .connectTimeout(Duration.ofMillis(jedisClientProperties.getConnectTimeout()))
                .readTimeout(Duration.ofMillis(jedisClientProperties.getReadTimeout()))
                .usePooling().poolConfig(genericObjectPoolConfig)
                .build();


        return new JedisConnectionFactory(standaloneConfiguration, jedisClientConfiguration);
    }

    @Bean
    public RedisTemplate<String, Object> defaultRedisTemplate(RedisConnectionFactory defaultJedisConnectionFactory) {
        //创建一个模板类
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        //将刚才的redis连接工厂设置到模板类中
        template.setConnectionFactory(defaultJedisConnectionFactory);
        StringRedisSerializer hashKeySerializer = new StringRedisSerializer();
        template.setKeySerializer(hashKeySerializer);
        template.setHashKeySerializer(hashKeySerializer);
        return template;
    }

    @Bean
    public StringRedisTemplate defaultStringRedisTemplate(RedisConnectionFactory defaultJedisConnectionFactory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(defaultJedisConnectionFactory);
        return stringRedisTemplate;
    }

    /**
     * 序列化不同(对象)
     *
     * @param defaultRedisTemplate
     * @return
     */
    @Bean
    public RedisUtil defaultRedisUtil(RedisTemplate<String, Object> defaultRedisTemplate) {
        return new RedisUtil(defaultRedisTemplate);
    }

    /**
     * (可视的数据)
     *
     * @param defaultStringRedisTemplate
     * @return
     */
    @Bean
    public StringTemplateRedisUtil defaultStringTemplateRedisUtil(StringRedisTemplate defaultStringRedisTemplate) {
        return new StringTemplateRedisUtil(defaultStringRedisTemplate);
    }

}

单机版 yml配置

  #单机版配置
com:
  warape:
   redis:
     standalone:
       client:
         host-name: 10.20.29.71
         port: 6379
         connectTimeout: 2000
         readTimeout: 1000
       pool:
         max-total: 100
         max-idle: 10
         max-wait-millis: 1000

properties 集群版

/**
 * Jedis集群配置类
 *
 * @author warApe
 */
@Data
public class JedisClusterConfigProperties {
    private int connectTimeout;
    private int readTimeout;
    private int maxRedirections;
    private List<String> jedisClusterNodes;
}


/**
 * @author warApe
 * @date 2018/5/14 14:25
 */
@Data
public class JedisClusterPoolProperties {

    private int maxTotal;
    private int maxIdle;
    private int maxWaitMillis;
}

BeanConfig 集群版

/**
 * @program: springboot-share
 * @description: bean加载config
 * @author: warApe
 * @create: 2019-05-31 14:58
 **/
@Configuration
public class BeanConfig {

    @Bean
    @ConfigurationProperties(prefix = "com.warape.redis.pool")
    public JedisClusterPoolProperties jedisClusterPoolProperties() {
        return new JedisClusterPoolProperties();
    }

    @Bean
    @ConfigurationProperties(prefix = "com.warape.redis.cluster")
    public JedisClusterConfigProperties jedisClusterConfigProperties() {
        return new JedisClusterConfigProperties();
    }


}

JedisClientConfig 配置 集群版

package com.warape.springbootshare.integrated.configs;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.warape.springbootshare.SpringbootShareApplication;
import com.warape.springbootshare.integrated.properties.JedisClusterConfigProperties;
import com.warape.springbootshare.integrated.properties.JedisClusterPoolProperties;
import com.warape.springbootshare.integrated.utils.RedisUtil;
import com.warape.springbootshare.integrated.utils.StringTemplateRedisUtil;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * 集群版
 *
 * @author warApe
 * @date 2018/7/29 18:03
 * @see SpringbootShareApplication @EnableRedisConfigType
 */
//@Profile({"dev","pro"})
public class JedisClusterConfig {

    private JedisClusterPoolProperties jedisClusterPoolProperties;
    private JedisClusterConfigProperties JedisClusterConfigProperties;

    @Autowired
    public JedisClusterConfig(JedisClusterPoolProperties jedisClusterPoolProperties, JedisClusterConfigProperties jedisClusterConfigProperties) {
        this.jedisClusterPoolProperties = jedisClusterPoolProperties;
        JedisClusterConfigProperties = jedisClusterConfigProperties;
    }

    @Bean
    public RedisConnectionFactory jedisConnectionFactoryCluster1() {

        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(JedisClusterConfigProperties.getJedisClusterNodes());
        redisClusterConfiguration.setMaxRedirects(JedisClusterConfigProperties.getMaxRedirections());
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        //最大空闲
        genericObjectPoolConfig.setMaxIdle(jedisClusterPoolProperties.getMaxIdle());
        //链接池中最大连接数
        genericObjectPoolConfig.setMaxTotal(jedisClusterPoolProperties.getMaxTotal());
        //最小空闲
        genericObjectPoolConfig.setMinIdle(jedisClusterPoolProperties.getMaxIdle());
        //连接池资源耗尽后  最大等待时间
        genericObjectPoolConfig.setMaxWaitMillis(jedisClusterPoolProperties.getMaxWaitMillis());

        JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder()
                .connectTimeout(Duration.ofMillis(JedisClusterConfigProperties.getConnectTimeout()))
                .readTimeout(Duration.ofMillis(JedisClusterConfigProperties.getReadTimeout()))
                .usePooling().poolConfig(genericObjectPoolConfig)
                .build();
        return new JedisConnectionFactory(redisClusterConfiguration, jedisClientConfiguration);
    }

    /**
     * redisClusterTemplateCluster1
     *
     * @param jedisConnectionFactoryCluster1 参数名为beanName
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisClusterTemplateCluster1(RedisConnectionFactory jedisConnectionFactoryCluster1) {
        //创建一个模板类
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        //将刚才的redis连接工厂设置到模板类中
        template.setConnectionFactory(jedisConnectionFactoryCluster1);
        //初始化redis key中的序列化方式 StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        //初始化redis value中的序列化方式 fastjson序列化
        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();
        template.setHashValueSerializer(serializer);
        template.setValueSerializer(serializer);
        return template;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplateCluster1(RedisConnectionFactory jedisConnectionFactoryCluster1) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(jedisConnectionFactoryCluster1);
        return stringRedisTemplate;
    }

    /**
     * 序列化不同(对象)
     *
     * @param redisClusterTemplateCluster1
     * @return
     */
    @Bean
    public RedisUtil redisUtilCluster1(RedisTemplate<String, Object> redisClusterTemplateCluster1) {
        return new RedisUtil(redisClusterTemplateCluster1);
    }


    /**
     * (可视的数据)
     *
     * @param stringRedisTemplateCluster1
     * @return
     */
    @Bean
    public StringTemplateRedisUtil StringRedisUtilCluster1(StringRedisTemplate stringRedisTemplateCluster1) {
        return new StringTemplateRedisUtil(stringRedisTemplateCluster1);
    }


}

集群yml配置

#集群版配置
com:
  warape:
    redis:
      pool:
        maxTotal: 100
        maxIdle: 10
        maxWaitMillis: 3000
      cluster:
        connectTimeout: 2000
        readTimeout: 1000
        maxRedirections: 5
        jedisClusterNodes: 10.143.131.63:6391,10.143.131.63:6392,10.143.131.63:6393,10.143.131.63:6394,10.143.131.63:6395,10.143.131.63:6396
      #如果为多个集群 一次类推
#      cluster1:
#        connectTimeout:
#        readTimeout:
#        maxRedirections:
#        jedisClusterNodes:
#      pool1:
#        maxTotal: 100
#        maxIdle: 10
#        maxWaitMillis: 3000

注:

有2个工具类我没有贴出来,太长了,请小伙伴们去github上去找一下
分别为:StringTemplateRedisUtil 和 RedisUtil

项目github地址:

https://github.com/warApePoint/springboot-share

SpringBoot2.X整合Redis(单机+集群+多数据源)-Lettuce版
lonely_bin的博客
08-29 9927
Redis 三大客户端 简介 Jedis：是Redis 老牌的Java实现客户端，提供了比较全面的Redis命令的支持， Redisson：实现了分布式和可扩展的Java数据结构。 Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。 优点： Jedis：比较全面的提供了Redis的操作特性 Redisson：促使使用者对Redis的关...
springboot + redis集群和单机切换（密码）自定义配置文件
SmileTimLi的博客
05-08 3552
项目中因为不是使用springRedis的配置，而是采用自定义的配置redis.pool，而且需要进行单机和集群的切换，中间出现了一些jar包冲突的问题，导致部分功能不能使用，还是记录一下，这个找了好久 1、配置文件如下，可能和现行的配置不同，使用model进行区分，当然代码有判断 redis: pool: maxTotal: 120 # 最大连接数 maxIdle: 3...
玩转 SpringBoot 2.x 之 快速集成 Jedis客户端（普通版）
12-22
前言 Java 开发 一般会选择 Jedis 客户端来进行 Redis 相关的操作，本文通过SpringBoot 项目带你快速上手 Jedis 相关的操作。 Redis 安装 请参考：带你学 Redis：Redis安装（二） 代码案例 基础配置操作 引入 jedis 客户端的依赖，具体代码如下： redis.clients jedis 添加 Jedis 客户端配置类，将JedisPoolConfig和 JedisPool 注入Spring的上下文中。具体代码如下： @Configuration public class JedisConfig { @Value("${redis
redis 集群使用
heroguo007的专栏
10-20 507
如果使用的是redis2.x，在项目中使用客户端分片（Shard）机制,已经很久之前的版本,该换新了(此处略过), 本文讲解基于redis3.x中的集群，通过两部分来阐述spring boot整合redis,在项目中使用jedisCluster机制。 第一部分:spring boot自带整合的redis,比较简单,看下来 1>不用多说,pom.xml文件增加redis与sprin
Redis集群搭建+SpringBoot整合
最新发布
weixin_46852011的博客
04-06 592
redis集群搭建，SpringBoot整合，一台服务器搭建集群
Spring Boot 2.x Redis多数据源配置(jedis,lettuce)
agg7911的博客
03-06 182
Spring Boot 2.x Redis多数据源配置(jedis,lettuce) 96 不敢预言的预言家 0.1 2018.11.13 14:22* 字数 65 阅读 727评论 0喜欢 2 多数据源最终表现其实就是 redis connection factory 不同 springboot 默认的redis配置维护了一套 connection factory ...
基于SpringBoot 2.X整合Jedis
SLy .的博客
12-20 6566
##基于SpringBoot 2.X整合Jedis 说明：本文旨在整理SpringBoot 2.X整合Jedis基础功能，如有问题请指出 一. 基于redis.properties配置文件整合 基于redis.properties配置文件整合采用单例模式读取redis配置文件形式，用静态代码块初始化JedisPool，此时成员变量由配置文件读取，且需要声明为static（若采用注解形式读取...
SpringBoot 2.x版本整合redis集群
.
03-15 651
SpringBoot 2.x版本整合redis集群 启动 Redis集群 搭建方式 导入依赖 <!-- redis缓存 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...
SpringBoot中使用redis(单机+集群)
swadian2008的博客
03-03 4345
目录 引入依赖 参数配置 测试访问 RedisTemplate相关配置 集群版 Spring Boot中除了对常用的关系型数据库提供了优秀的自动化支持之外，对于很多NoSQL数据库一样提供了自动化配置的支持，包括：Redis, MongoDB, Elasticsearch, Solr和Cassandra。 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库。 引入依赖 Spring Boot提供数据访问框架Spring Data
spring boot配置同时支持单机和集群redis
Destiny宿命的博客
10-11 7183
正式环境都是用集群版redis，开发用的单机版，领导要求通过配置文件来确定是单机还是集群，由于单机版已经实现了，那么准备就在单机版基础上进行开发，然后发现spring boot1.2版本已经比较老，就升级版本，由于升级了spring boot版本，对应其他配置也进行了修改。最终修改的配置如下： pom.xml &lt;properties&gt; &lt;java.version&gt;1...
【SpringBoot整合Redis测试Redis集群案例】
awd15771131554的博客
09-25 1292
如图，创建项目遇到的第一个问题就是，当type选择maven，jdk选择1.8时，java部分没办法选择1.8的版本，这怎么办呢？原因：搜了一下，原来是官网的3.xx版本出来后，不再支持jdk1.8了，最低版本要求是jdk17解决办法：如果是个人练习的话，jdk可以安装jdk1.8，也可以再安装一个jdk17，跟上主流版本。
springboot+redis单机与集群
06-10
代码版 springboot+redis单机与集群
SpringBoot2.x整合Redis集群
qq_37163392的博客
02-19 305
SpringBoot2.x整合Redis集群 添加依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- 连接池 --> <dependency&gt
springboot2.x整合Redis 之 jedis
哈
11-04 462
第一步：创建项目，添加Maven依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.10</version> </dependency> <dependency> <groupId>com.fasterxml.j
Spring boot2.x整合redis 或者 集群
zgz15515397650的博客
02-27 824
一、搭建单机版的redis 1.pom.xml Spring boot 2.0以上的redis都是使用 lettuce来进行链接的，不过这里用的是jedis &lt;!--redis--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
springboot2.x 集成 redis cluster
qq_38946877的博客
08-09 410
springboot2.x 集成 redis cluster 1，添加依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 ht
SpringBoot 整合Redis同时支持单机和集群模式
Sibylsf的博客
04-28 7374
Redis是干啥的，我就不在这说了，我说的肯定很肤浅，不出意外，你们会觉得我说了和没说一样，所以大家还是去找度娘靠谱。 下面分不同情况来设置：（我这里是yml配置，properties和这个类似） 一、单机redis配置 适用于：生产、测试、 redis: # Redis数据库索引（默认为0） database: 0 host: xxx.xxx.xx.xx ...
springBoot整合Redis（单机版和集群版）
热门推荐
延陵缥缈的博客
05-30 1万+
        Spring Boot中除了对常用的关系型数据库提供了优秀的自动化支持之外，对于很多NoSQL数据库一样提供了自动化配置的支持，包括：Redis, MongoDB, Elasticsearch, Solr和Cassandra。        Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，这里将对SpringBoot...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿道apeto

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值