spring.redis.cluster.nodes spring.redis.cluster.nodes配置

转载

晨曦微露s 2023-08-05 18:28:20

文章标签 redis spring java 文章分类 Redis 数据库

这里说说在spring boot 下redis的配置和简单使用，这里前提时你的redis已经安装好

通过maven添加对redis的支持：

<!-- 添加redis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version><!--$NO-MVN-MAN-VER$ -->
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.4</version>
		</dependency>

在application.properties添加redis配置信息

#redis配置
#节点，多个节点用,分隔：127.0.0.1:6379,127.0.0.1:6378,127.0.0.1:6377
#spring.redis.cluster.nodes=172.30.12.14:6379
spring.redis.cluster.ip=172.30.12.14
spring.redis.cluster.port=6379
spring.redis.cluster.password=inhand@redis2017
#最大连接数, 默认8个,一些低版本的包是maxActive，如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
spring.redis.cluster.maxTotal=100
#控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
spring.redis.cluster.maxIdle=20
#控制一个pool最少有多少个状态为idle(空闲的)的jedis实例。
spring.redis.cluster.minIdle=2
#等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
spring.redis.cluster.maxWait=10000
#在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的
spring.redis.cluster.testOnBorrow=true
#jedis调用returnObject方法时，是否进行有效检查
spring.redis.cluster.testOnReturn=false
#读取超时
spring.redis.cluster.timeout=5000
#连接超时
spring.redis.cluster.connectionTimeout=5000
#最大尝试次数
spring.redis.cluster.maxAttempts=3

然后通过sping boot强大的注解功能，帮我们把配置信息注入到实体类：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


// 特别注意：@ConfigurationProperties(prefix = "spring.redis.cluster")
// 中spring.redis.cluster要和application.properties中的前缀对应。
@Component
@ConfigurationProperties(prefix = "spring.redis.cluster")
public class RedisProperties
{

    // 自动注入redis配置
    private String nodes;

    private String ip;

    private int port;

    private String password;

    private int maxTotal;

    private int maxIdle;

    private int minIdle;

    private int maxWait;

    private boolean testOnBorrow;

    private boolean testOnReturn;

    private int timeout;

    private int connectionTimeout;

    private int maxAttempts;

    public String getNodes()
    {
        return nodes;
    }

    public void setNodes(String nodes)
    {
        this.nodes = nodes;
    }

    public String getIp()
    {

        return ip;
    }

    public void setIp(String ip)
    {

        this.ip = ip;
    }

    public int getPort()
    {

        return port;
    }

    public void setPort(int port)
    {

        this.port = port;
    }

    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

    public int getMaxTotal()
    {
        return maxTotal;
    }

    public void setMaxTotal(int maxTotal)
    {
        this.maxTotal = maxTotal;
    }

    public int getMaxIdle()
    {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle)
    {
        this.maxIdle = maxIdle;
    }

    public int getMinIdle()
    {
        return minIdle;
    }

    public void setMinIdle(int minIdle)
    {
        this.minIdle = minIdle;
    }

    public int getMaxWait()
    {
        return maxWait;
    }

    public void setMaxWait(int maxWait)
    {
        this.maxWait = maxWait;
    }

    public boolean isTestOnBorrow()
    {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow)
    {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn()
    {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn)
    {
        this.testOnReturn = testOnReturn;
    }

    public int getTimeout()
    {
        return timeout;
    }

    public void setTimeout(int timeout)
    {
        this.timeout = timeout;
    }

    public int getConnectionTimeout()
    {
        return connectionTimeout;
    }

    public void setConnectionTimeout(int connectionTimeout)
    {
        this.connectionTimeout = connectionTimeout;
    }

    public int getMaxAttempts()
    {
        return maxAttempts;
    }

    public void setMaxAttempts(int maxAttempts)
    {
        this.maxAttempts = maxAttempts;
    }

}

然后在初始化连接：

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import redis.clients.jedis.JedisPool;



@Configuration
public class ApplicationConfig extends WebMvcConfigurerAdapter
{


    // ---------------配置redis-----------------------

    /**
     * 1、JedisCluster管理集群与ShardedJedisPool分片连接池实现分布式的区别
     * ShardedJedisPool是redis没有集群功能之前客户端实现的一个数据分布式方案
     * ，redis3.0提供集群之后，客户端则采用JedisCluster实现连接redis集群环境。
     * ShardedJedisPool使用的是JedisShardInfo的instance的顺序或者name来做的一致性哈希 ，JedisCluster使用的是CRC16算法来做的哈希槽。
     * redis cluster配置集群与使用Jedis的ShardedJedis做Redis集群的区别 2、集群环境，各个服务之间的数据是隔离的
     * 无论是ShardedJedisPool的一致性哈希算法还是JedisCluster的CRC16哈希槽算法，都是把所有的服务叠加然后进行均匀的分割，
     * 分割出来的每一个段或槽都是不重复的，所以导致存储的数据彼此之间也是处于隔离状态的。
     * 3、jedis客户端操作redis主要三种模式：单台模式、分片模式（ShardedJedis）、集群模式（BinaryJedisCluster）， 分片模式是一种轻量级集群
     **/

	 //注入配置属性的类
    @Autowired
    private RedisProperties redisProperties;

    /**
     * 注意： 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用 使用：
     * 
     * @Autowired private JedisCluster jc;
     */
	 
	 /**
     * redis集群模式
     * 
     * @return
     */
    // @Bean
    // public JedisCluster getJedisCluster() {
    //
    // String[] serverArray = redisProperties.getNodes().split(",");//
    // 获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
    // Set<HostAndPort> nodes = new HashSet<>();
    //
    // for (String ipPort : serverArray) {
    // String[] ipPortPair = ipPort.split(":");
    // nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer
    // .valueOf(ipPortPair[1].trim())));
    // }
    //
    // //集群配置
    // JedisCluster jc = new JedisCluster(nodes,
    // redisProperties.getConnectionTimeout(),
    // redisProperties.getTimeout(), redisProperties.getMaxAttempts(),
    // redisProperties.getPassword(), genericObjectPoolConfig());
    //
    // return jc;
    //
    // }

    /**
     * redis单机模式
     * 
     * @return
     */
    @Bean
    public JedisPool getJedisPool()
    {

        JedisPool jedisPool = new JedisPool(genericObjectPoolConfig(), redisProperties.getIp(),
            redisProperties.getPort(), redisProperties.getTimeout(), redisProperties.getPassword());

        return jedisPool;
    }

    /**
     * 初始化连接池
     * 
     * @return
     */
    private GenericObjectPoolConfig genericObjectPoolConfig()
    {

        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();

        poolConfig.setMaxTotal(redisProperties.getMaxTotal());
        poolConfig.setMaxIdle(redisProperties.getMaxIdle());
        poolConfig.setMinIdle(redisProperties.getMinIdle());
        poolConfig.setMaxWaitMillis(redisProperties.getMaxWait());
        poolConfig.setTestOnBorrow(redisProperties.isTestOnBorrow());
        poolConfig.setTestOnReturn(redisProperties.isTestOnReturn());

        return poolConfig;
    }

}

到这基本可以使用了。

示例：

@Autowired
    private JedisPool jedisPool;

 public String get(String key)
    {
        Jedis jedis = null;
        String ret = null;
        try
        {
            jedis = jedisPool.getResource();
            ret = jedis.get(key);
        }
        catch (Exception e)
        {
            log.error(this, e);
        }
        finally
        {
            jedis.close();
        }
        return ret;
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。