jedis 集群配置

最新推荐文章于 2024-09-04 21:51:13 发布
最新推荐文章于 2024-09-04 21:51:13 发布
阅读量2.1k 收藏
点赞数
文章标签： 数据库 java
原文链接：http://blog.51cto.com/jtech/2336286
版权

pom引入jar包

        <!-- redis start -->
        <dependency> 
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!-- redis end -->
···
### spring配置
<bean id="myJedisClusterHelper" class="com.redis.JedisClusterHelper">
    <property name="jedisCluster" ref="myJedisClusterFactory" />
</bean>
<!-- redis集群 -->
<bean id="myJedisClusterFactory" class="com.redis.JedisClusterFactory">
    <property name="connectionTimeout" value="3000" />
    <property name="soTimeout" value="3000" />
    <property name="maxRedirections" value="5" />
    <property name="genericObjectPoolConfig" ref="myJedisClusterPoolConfig" />
    <property name="jedisClusterNodes">
    <set>
        <!-- 生产环境 -->
        <value>${spring.redis.cluster.nodes1}</value>
        <value>${spring.redis.cluster.nodes2}</value>
        <value>${spring.redis.cluster.nodes3}</value>
        <value>${spring.redis.cluster.nodes4}</value>
        <value>${spring.redis.cluster.nodes5}</value>
        <value>${spring.redis.cluster.nodes6}</value>
    </set>
    </property>
</bean>
<!-- redis3.2集群配置 -->
<bean id="myJedisClusterPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxTotal" value="50" />
    <property name="maxIdle" value="5" />
    <property name="maxWaitMillis" value="100000" />
    <property name="testOnBorrow" value="true" />
</bean>
### redis.properties配置文件

###redis集群
spring.redis.cluster.nodes1=127.0.0.1:6380
spring.redis.cluster.nodes2=127.0.0.1:6381
spring.redis.cluster.nodes3=127.0.0.1:6382
spring.redis.cluster.nodes4=127.0.0.1:6390
spring.redis.cluster.nodes5=127.0.0.1:6391
spring.redis.cluster.nodes6=127.0.0.1:6392

Redis数据库索引(默认为0)

spring.redis.database=0

连接超时时间（毫秒）

spring.redis.timeout=60000

最大重试次数

spring.redis.maxRedirects=3

连接池最大连接数（使用负值表示没有限制）

spring.redis.pool.max-active=300

连接池最大阻塞等待时间（使用负值表示没有限制）

spring.redis.pool.max-wait=-1

连接池中的最大空闲连接

spring.redis.pool.max-idle=100

连接池中的最小空闲连接

spring.redis.pool.min-idle=20

### JedisClusterFactory.java集群工厂类

package com.redis;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

/**

  • 读取redis集群节点
  • @author

  • */
    public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean{
    private GenericObjectPoolConfig genericObjectPoolConfig;
    private JedisCluster jedisCluster;
    private int connectionTimeout = 2000;
    private int soTimeout = 3000;
    private int maxRedirections = 5;
    private Set<String> jedisClusterNodes;

    public void afterPropertiesSet() throws Exception {
    if (jedisClusterNodes == null || jedisClusterNodes.size() == 0) {
    throw new NullPointerException("jedisClusterNodes is null.");
    }
    Set<String> nodesStrSet = new LinkedHashSet<String>();
    Set<HostAndPort> haps = new LinkedHashSet<HostAndPort>();
    for (String node : jedisClusterNodes) {
    if (StringUtils.contains(node, "-")) {
    nodesStrSet.addAll(Arrays.asList(convertHostIpSectionToList(node)));
    } else {
    nodesStrSet.add(node);
    }
    }
    for (String node : nodesStrSet) {
    String[] arr = node.split(":");
    if (arr.length != 2) {
    throw new ParseException("node address error !", node.length() - 1);
    }
    haps.add(new HostAndPort(arr[0], Integer.valueOf(arr[1])));
    }
    jedisCluster = new JedisCluster(haps, connectionTimeout, maxRedirections, genericObjectPoolConfig);
    }

    /**

    • 将IP段与端口段拆分为详细的IP:端口

    • @param addresses IP段\端口段，格式为：xxx.xxx.xxx.xxx-xxx:xxxxx-xxxxx
      */
      private String[] convertHostIpSectionToList(String addresses) {

      if (StringUtils.isBlank(addresses)) {
      throw new IllegalArgumentException("The addresses parameter must not be null.");
      }
      String[] split = StringUtils.split(addresses, ":");
      String hostSection = split[0], portSection = split[1];
      hostSection = hostSection.trim();
      portSection = portSection.trim();
      List<String> hostList = new ArrayList<String>();
      List<Integer> portList = new ArrayList<Integer>();

      if (StringUtils.countMatches(hostSection, ".") != 3) {
      throw new IllegalArgumentException("The hostSection [" + hostSection + "] format is incorrect.");
      }
      int hostMatches = StringUtils.countMatches(hostSection, "-");
      if (hostMatches == 0) {
      hostList.add(hostSection);
      } else if (hostMatches == 1) {
      String hostSectionLast = StringUtils.substringAfterLast(hostSection, ".");
      String hostFixed = StringUtils.replace(hostSection, hostSectionLast, StringUtils.EMPTY);
      String[] hostSections = StringUtils.split(hostSectionLast, "-");
      if (hostSections.length != 2) {
      throw new IllegalArgumentException("The hostSection [" + hostSection + "] format is incorrect.");
      }
      int start = Integer.valueOf(hostSections[0]), end = Integer.valueOf(hostSections[1]);
      for (int i = start; i <= end; i++) {
      hostList.add(String.valueOf(hostFixed + i));
      }
      } else {
      throw new IllegalArgumentException("The hostSection [" + hostSection + "] format is incorrect.");
      }
      String[] portSections = StringUtils.split(portSection, "-");
      if (portSections.length == 1) {
      portList.add(Integer.valueOf(portSections[0]));
      } else if (portSections.length == 2) {
      int start = Integer.valueOf(portSections[0]), end = Integer.valueOf(portSections[1]);
      for (int port = start; port <= end; port++) {
      portList.add(port);
      }
      } else {
      throw new IllegalArgumentException("The portSection [" + portSection + "] format is incorrect.");
      }

      Set<String> rtnValue = new LinkedHashSet<String>();
      for (String host : hostList) {
      for (Integer port : portList) {
      rtnValue.add(String.format("%s:%d", host, port));
      }
      }
      return rtnValue.toArray(new String[rtnValue.size()]);
      }

    public JedisCluster getObject() throws Exception {
    return jedisCluster;
    }

    public Class<?> getObjectType() {
    return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
    }

    public boolean isSingleton() {
    return true;
    }

    public GenericObjectPoolConfig getGenericObjectPoolConfig() {
    return genericObjectPoolConfig;
    }

    public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) {
    this.genericObjectPoolConfig = genericObjectPoolConfig;
    }

    public JedisCluster getJedisCluster() {
    return jedisCluster;
    }

    public void setJedisCluster(JedisCluster jedisCluster) {
    this.jedisCluster = jedisCluster;
    }

    public int getConnectionTimeout() {
    return connectionTimeout;
    }

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

    public int getSoTimeout() {
    return soTimeout;
    }

    public void setSoTimeout(int soTimeout) {
    this.soTimeout = soTimeout;
    }

    public int getMaxRedirections() {
    return maxRedirections;
    }

    public void setMaxRedirections(int maxRedirections) {
    this.maxRedirections = maxRedirections;
    }

    public Set<String> getJedisClusterNodes() {
    return jedisClusterNodes;
    }

    public void setJedisClusterNodes(Set<String> jedisClusterNodes) {
    this.jedisClusterNodes = jedisClusterNodes;
    }
    }

    ###  JedisClusterHelper.java集群帮助工具类

    package com.redis;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeSet;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**

  • jedis集群帮助类
  • <p>Title: JedisClusterHelper</p>
  • <p>Description: </p>
  • @author

  • @date 2018-7-2
    */
    public class JedisClusterHelper{

    private static Logger log = LoggerFactory.getLogger(JedisClusterHelper.class);
    private JedisCluster jedisCluster;

    public JedisCluster getJedisCluster() {
    return jedisCluster;
    }

    public void setJedisCluster(JedisCluster jedisCluster) {
    this.jedisCluster = jedisCluster;
    }

    /**

    • <p>Title: get</p>
    • <p>Description: </p>
    • @param format
    • @return
      */
      public String get(String key) {
      return jedisCluster.get(key);
      }

    public void set(String key,String value) {
    jedisCluster.set(key, value);
    }

    public void expire(String key,int seconds) {
    try {
    jedisCluster.expire(key, seconds);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    }

    public void setExpire(String key,String value,int seconds){
    try {
    jedisCluster.set(key, value);
    jedisCluster.expire(key, seconds);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    }

    public boolean exists(String key) {
    boolean resultExists = false;
    try {
    resultExists = jedisCluster.exists(key);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    resultExists = false;
    }
    return resultExists;
    }

    public void del(String key) {
    try{
    jedisCluster.del(key);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    }

    /**

    • 自增器
    • <p>Title: incr</p>
    • <p>Description: </p>
    • @param key
      */
      public int incr(String key) {
      int resultIncr = 0;
      try {
      resultIncr = jedisCluster.incr(key).intValue();
      } catch (Exception e) {
      log.error("redis集群错误", e);
      resultIncr = 0;
      }
      return resultIncr;
      }

    public void incrExpire(String key,int seconds){
    try {
    jedisCluster.incr(key);
    jedisCluster.expire(key, seconds);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    }

    public Map<String, String> getSnapShots(String key) {
    Map resultMap = null;
    try {
    resultMap = jedisCluster.hgetAll(key);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    if (resultMap == null) {
    resultMap = new HashMap<String, String>();
    }
    return resultMap;
    }

    public Set<String> smembers(String key) {
    Set<String> resultSet = null;
    try {
    resultSet = jedisCluster.smembers(key);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    if (resultSet == null) {
    resultSet = new HashSet<String>();
    }
    return resultSet;
    }

    public Long expireAt(String key, long unixTime) {
    try {
    return jedisCluster.expireAt(key, unixTime);
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    return null;
    }

    public Set<String> getKeysAll(String likeKey) {
    TreeSet<String> keys = new TreeSet<String>();
    try {
    if (isNotBlank(likeKey)) {
    Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes();
    log.info("getKeysAll start:" + likeKey);
    for(String k : clusterNodes.keySet()){
    JedisPool jp = clusterNodes.get(k);
    Jedis connection = jp.getResource();
    try {
    keys.addAll(connection.keys(likeKey));
    } catch(Exception e){
    log.error("Getting keys error: {}", e);
    } finally{
    log.debug("Connection closed.");
    connection.close();//用完一定要close这个链接！！！
    }
    }
    log.info("getKeysAll end:" + likeKey + "keys.size:" + keys.size());
    }
    } catch (Exception e) {
    log.error("redis集群错误", e);
    }
    return keys;
    }

    public Map<String, String> getStrMap(String mapName) {
    Map<String, String> mapStr = null;
    try {
    if (mapName != null && !"".equals(mapName)) {
    // 获取List下的所有值
    mapStr = jedisCluster.hgetAll(mapName);
    }
    } catch (Exception e) {
    log.error("redis集群错误",e);
    }

    return mapStr;

    }

    public Object getObj(String key) {
    if (key != null && !"".equals(key)) {
    byte[] byteKey = key.getBytes();
    byte[] result = this.getByte(byteKey);// 获取byte类型的数据
    Object obj = null;
    if (result != null) {

            obj = SerializeUtil.unserialize(result);
    }

    return obj;
}

return null;

    }

    public byte[] getByte(byte[] key) {
    try {
    return jedisCluster.get(key);
    } catch (Exception e) {
    log.error("getByte:[key=" + key + "] occur exception..." + e.getMessage(), e);
    }
    return null;
    }

    public long setStrMap(String mapName, String key, String value) {
    long result = -1;
    try {
    if (mapName != null && !"".equals(mapName)) {
    // 向set中存放值
    result = jedisCluster.hset(mapName, key, value);
    }
    } catch (Exception e) {
    log.error("setStrMap:[mapName=" + mapName + ";key=" + key + ";value=" + value + "] occur exception..."

    • e.getMessage(), e);
      }
      return result;
      }

    public long delStrMap(String mapName, String key) {
    long result = -1;
    try {
    if (mapName != null && !"".equals(mapName)) {
    // 向set中存放值
    result = jedisCluster.hdel(mapName, key);
    }
    } catch (Exception e) {
    log.error("setStrMap:[mapName=" + mapName + ";key=" + key + "] occur exception..."

    • e.getMessage(), e);
      }
      return result;
      }

    public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0)
    return true;
    for (int i = 0; i < strLen; i++)
    if (!Character.isWhitespace(str.charAt(i)))
    return false;

    return true;

    }

    public static boolean isNotBlank(String str) {
    return !isBlank(str);
    }
    }

    ### 使用方法

    @Autowired
    private JedisClusterHelper myJedisClusterHelper;

    myJedisClusterHelper.set("testkey","testvalue");

转载于:https://blog.51cto.com/jtech/2336286

weixin_33836874
关注
深入学习 Redis - 基于 Jedis 通过 Java 客户端操作 Redis 和 Redis 集群
CYK_byte的博客
07-30 1078
我们在本地 windows 主机上，使用 xshell 连接远程服务器，主要就是通过 ssh 协议（默认走 22 端口）实现通信的，他有一个很重要的特性，就是支持端口转发！我们只需要配置 ssh 程序监听本地端口，映射到云服务器的端口，就可以实现通过 windows 主机，访问云服务器的 6379 端口.Ps：一个优秀的库，一定是非常容易上手的，因此接下来介绍的操作，不会覆盖到所有指令，会挑选出一些重要 / 代表性的命令，来进行演示~Ps：当配置了端口准发后，一定要断开之前的连接，重新连接才能生效.
springboot+redistemplate 集群配置
zxl8899的博客
08-07 1683
redisConfig 配置类 package com.zhouzhou.springredistemplatedemo.controller; import io.lettuce.core.cluster.ClusterClientOptions; import io.lettuce.core.cluster.ClusterTopologyRefreshOptions; import org.springframework.boot.autoconfigure.data.redis.RedisProp
jedis(redis)整合spring，包括jedis客户端单机版，jedis集群版配置 ，连接池配置
mine_song的博客
02-25 1131
jedis(redis)整合spring，包括jedis客户端单机版，jedis集群版配置 ，连接池配置
Spring-data-jedis集群配置
zsg88的专栏
05-28 653
该值 且 空闲连接>最大空闲连接数 时直接释放 -->
Redis三种集群搭建
最新发布
w13114的博客
09-04 1404
可以发现，只有在7001这个master节点上可以执行写操作，7002和7003这两个slave节点只能执行读操作。共包含三个节点，一个主节点，两个从节点。注意: 设置主从配置后reids会自动更改配置文件中的内容，确保重新复制master-slave中的配置到虚拟机中。因此节点列表中的前n个就是master，其它节点都是slave节点，随机分配到不同master。这里我们搭建一个三节点形成的Sentinel集群，来监管之前的Redis主从集群。要在同一台虚拟机开启3个实例，必须准备三份不同的配置文件。
JedisCluster配置集群api测试
fajing_feiyue的博客
01-26 2006
项目中会常用到redis，但JedisCluster的使用api还是比较多，经常可能会记不太清楚，故这里将大部分JedisCluster的api贴出来，供大家参考。 一、redis在工作是一个常见的工具，这里对redis和springboot形成集群的使用。 （1）引入对应redis集群所需要maven文件 <dependency> <groupId&g...
springboot jedis配置以及集群（第四篇） 实现redis单机和集群
ccr1001ccr1001的博客
07-28 1748
1.引入pom <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.3.0</version> </dependency> 2.实现自动配置导入 2.1定义yml内容 redis: cluster: nodes: 192.168.1.47:80...
springboot jedis配置以及集群（第五篇） redis-cli集群操作说明​​​​​​​
ccr1001ccr1001的博客
07-30 370
1.基本命令 2.具体命令操作 2.1创建 redis-cli -a password --cluster create 192.168.1.47:8082 192.168.1.47:8083 192.168.1.47:8084 192.168.1.47:8085 192.168.1.47:8086 192.168.1.47:8087 --cluster-replicas 1 2.2查询信息check --cluster-search-multiple-owners检查是否...
Jedis 操作Redis 集群demo
01-05
1. **配置JedisCluster**：在Java代码中，你需要创建一个`JedisCluster`实例，通常需要提供一组节点的IP地址和端口，以及集群的超时设置。示例代码如下： ```java Set<HostAndPort> nodes = new HashSet(); nodes...
jedisCluster 配置文件和调用Api
10-18
对jedischangyongApi的一些简单封装和分类，全部标有中文注释，可直接放入项目中使用，jedis集群配置可参考 https://blog.csdn.net/qq_31256487/article/details/83144088；
[Redis]Spring 整合Redis5.0集群【jedisCluster】
h609232722的专栏
02-22 2297
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>org.springframework.data</groupId>
redis集群环境搭建以及java中jedis客户端集群代码实现
04-26
NULL 博文链接：https://ihenu.iteye.com/blog/2267881
Redis集群|集群搭建|集群Jedis开发
云创网络工作室官方账号
11-10 1239
Redis集群搭建，集群Jedis开发。
redis安装以及php扩展
agehbcdsg099276191的博客
04-24 89
redis安装以及php扩展 启动安装： http://elain.blog.51cto.com/3339379/705846 redis下载： https://github.com/nicolasff/phpredis/downloads 多台服务安装： http://www.vquickphp.com/?a=blogview&id=30 ...
redis三：集群配置
admin522043032的博客
05-31 6625
文章目录redis集群配置主从复制搭建哨兵模式集群搭建 redis集群配置 不熟悉redis请先看：redis6学习 主从复制 主从模式指的是使用一个redis实例作为主机，其余的实例作为备份机。主机和从机的数据完全一致，主机支持数据的写入和读取等各项操作，而从机则只支持与主机数据的同步和读取，也就是说，客户端可以将数据写入到主机，由主机自动将数据的写入操作同步到从机。主从模式很好的解决了数据备份问题，并且由于主从服务数据几乎是一致的，因而可以将写入数据的命令发送给主机执行，而读取数据的命令发送给不同的从机
Redis——集群配置
z1171127310的博客
08-22 2374
Redis——集群配置
Jedis连接集群
weixin_30443075的博客
06-30 473
以maven项目为例：1.配置pom.xml: <dependencies> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.0.1</version> &lt...
Redis集群配置
houzhe_adore的博客
09-06 861
本博文采用 Sentinel + Redis方式实现Redis高可用集群搭建。Sentinel 是Redis官方提供的Redis Server监控程序。我们可以通过部署Sentinel监控各个Redis Server，当Master Server失效时，通过选举，将Slave提升为Master，继续为客户端提供服务。在使用Sentinel之前，首先要确定客户端是否支持，如不支持，请选择其他第三方方案
掌握Redis集群配置与Jedis代码封装技巧
资源摘要信息:"Redis的集群配置及代码封装" ...以上内容介绍了Redis的集群配置以及使用Jedis进行Redis操作的代码封装方法。掌握这些知识对于开发高性能的缓存应用和构建可扩展的数据库解决方案是非常重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值