SpringBoot通过JedisCluster连接Redis集群（分布式项目）

分布式项目 SpringBoot + Redis使用

现在开发流行微服务、分布式，基于这种情况需要使用redis不想每个项目都去写重复的代码，所以我在工具包中封装了redis这一块的连接，但是问题是所有的项目都会依赖我的基础包，却不是所有的项目都要使用redis。所以我需要根据业务系统的配置文件中是否配置了redis集群相关信息来确定是否去连redis。

首先引入maven包

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

分布式锁

• 1.新建类JedisLock

package com.xxx.util.redis;

import redis.clients.jedis.JedisCluster;

/**
 * Redis distributed lock implementation.
 */
public class JedisLock {

  JedisCluster jedis;

  /** Lock key path. */
  String lockKey;

  /** Lock expiration in miliseconds. */
  int expireMsecs = 60 * 1000; //锁超时，防止线程在入锁以后，无限的执行等待

  /** Acquire timeout in miliseconds. */
  int timeoutMsecs = 10 * 1000; //锁等待，防止线程饥饿

  boolean locked = false;
  /**
   * Detailed constructor with default acquire timeout 10000 msecs and lock expiration of 60000
   * msecs.
   *
   * @param jedis
   * @param lockKey lock key (ex. account:1, ...)
   */
  public JedisLock(JedisCluster jedis, String lockKey) {
    this.jedis = jedis;
    this.lockKey = lockKey;
  }

  /**
   * Detailed constructor with default lock expiration of 60000 msecs.
   *
   * @param jedis
   * @param lockKey lock key (ex. account:1, ...)
   * @param timeoutMsecs acquire timeout in miliseconds (default: 10000 msecs)
   */
  public JedisLock(JedisCluster jedis, String lockKey, int timeoutMsecs) {
    this(jedis, lockKey);
    this.timeoutMsecs = timeoutMsecs;
  }

  /**
   * Detailed constructor.
   *
   * @param jedis
   * @param lockKey lock key (ex. account:1, ...)
   * @param timeoutMsecs acquire timeout in miliseconds (default: 10000 msecs)
   * @param expireMsecs lock expiration in miliseconds (default: 60000 msecs)
   */
  public JedisLock(JedisCluster jedis, String lockKey, int timeoutMsecs, int expireMsecs) {
    this(jedis, lockKey, timeoutMsecs);
    this.expireMsecs = expireMsecs;
  }

  /**
   * Detailed constructor with default acquire timeout 10000 msecs and lock expiration of 60000
   * msecs.
   *
   * @param lockKey lock key (ex. account:1, ...)
   */
  public JedisLock(String lockKey) {
    this(null, lockKey);
  }

  /**
   * Detailed constructor with default lock expiration of 60000 msecs.
   *
   * @param lockKey lock key (ex. account:1, ...)
   * @param timeoutMsecs acquire timeout in miliseconds (default: 10000 msecs)
   */
  public JedisLock(String lockKey, int timeoutMsecs) {
    this(null, lockKey, timeoutMsecs);
  }

  /**
   * Detailed constructor.
   *
   * @param lockKey lock key (ex. account:1, ...)
   * @param timeoutMsecs acquire timeout in miliseconds (default: 10000 msecs)
   * @param expireMsecs lock expiration in miliseconds (default: 60000 msecs)
   */
  public JedisLock(String lockKey, int timeoutMsecs, int expireMsecs) {
    this(null, lockKey, timeoutMsecs, expireMsecs);
  }

  /** @return lock key */
  public String getLockKey() {
    return lockKey;
  }

  /**
   * Acquire lock.
   *
   * @return true if lock is acquired, false acquire timeouted
   * @throws InterruptedException in case of thread interruption
   */
  public boolean acquire() throws InterruptedException {
    return acquire(jedis);
  }

  /**
   * Acquire lock.
   *
   * @param jedis
   * @return true if lock is acquired, false acquire timeouted
   * @throws InterruptedException in case of thread interruption
   */
  public boolean acquire(JedisCluster jedis) throws InterruptedException {
    int timeout = timeoutMsecs;
    while (timeout >= 0) {
      long expires = System.currentTimeMillis() + expireMsecs + 1;
      String expiresStr = String.valueOf(expires); //锁到期时间
      if (jedis.setnx(lockKey, expiresStr) == 1) {
        locked = true;
        return true;
      }

      String currentValueStr = jedis.get(lockKey); //redis里的时间
      if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
        //判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的
        String oldValueStr = jedis.getSet(lockKey, expiresStr);
        //获取上一个锁到期时间，并设置现在的锁到期时间，
        if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
          //如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
          locked = true;
          return true;
        }
      }
      timeout -= 100;
      Thread.sleep(100);
    }
    return false;
  }

  /** Acqurired lock release. */
  public void release() {
    release(jedis);
  }

  /** Acqurired lock release. */
  public void release(JedisCluster jedis) {
    if (locked) {
      jedis.del(lockKey);
      locked = false;
    }
  }
}

• 2.新建类SimpleLock

package com.xxx.util.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.JedisCluster;

public class SimpleLock {
  private static Logger logger = LoggerFactory.getLogger(SimpleLock.class);
  private JedisLock jedisLock;
  private String lockKey;
  private JedisCluster jedis;
  private int timeoutMsecs;
  private int expireMsecs;

  public SimpleLock(String lockKey, JedisCluster jedis) {
    this(lockKey, 120000, 300000, jedis);
  }

  public SimpleLock(String lockKey, int timeoutMsecs, int expireMsecs, JedisCluster jedis) {
    this.lockKey = lockKey;
    this.jedis = jedis;
    this.timeoutMsecs = timeoutMsecs;
    this.expireMsecs = expireMsecs;
    this.jedisLock = new JedisLock(jedis, lockKey.intern(), timeoutMsecs, expireMsecs);
  }

  public synchronized void wrap(Runnable runnable) throws Exception {
    long begin = System.currentTimeMillis();
    try {
      logger.info(
          "begin lock,lockKey={},timeoutMsecs={},expireMsecs={}",
          lockKey,
          timeoutMsecs,
          expireMsecs);
      if (jedisLock.acquire()) { // 启用锁
        runnable.run();
      } else {
        logger.info("The time wait for lock more than [{}] ms ", timeoutMsecs);
        throw new Exception("can not get lock");
      }
    } catch (Throwable t) {
      // 分布式锁异常
      logger.warn(t.getMessage(), t);
      throw t;
    } finally {
      this.lockRelease(jedisLock);
    }
    logger.info("[{}]cost={}", lockKey, System.currentTimeMillis() - begin);
  }

  /**
   * 释放锁
   * @param lock
   */
  private void lockRelease(JedisLock lock) {
    if (lock != null) {
      try {
        lock.release();
      } catch (Exception e) {

      }
    }
    logger.debug(
        "release logck,lockKey={},timeoutMsecs={},expireMsecs={}",
        lockKey,
        timeoutMsecs,
        expireMsecs);
  }
}

注：根据实际情况确定是否需要使用到锁，以上并非一定需要有的。一切的一切都是业务决定

使用JedisCluster连接redis集群

新建类RedisAutoConfiguration

package com.xxx.util.redis;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

import java.util.HashSet;
import java.util.Set;

/**
 * @author <a href="mailto:zhibo.lv@wolaidai.com">zhibo.lv</a>
 */
@Configuration
public class RedisAutoConfiguration {

    @Value("${redis.node1.ip:127.0.0.1}")
    private String node1Ip;
    @Value("${redis.node1.port:0}")
    private int node1Port;
    @Value("${redis.node2.ip:127.0.0.1}")
    private String node2Ip;
    @Value("${redis.node2.port:0}")
    private int node2Port;
    @Value("${redis.node3.ip:127.0.0.1}")
    private String node3Ip;
    @Value("${redis.node3.port:0}")
    private int node3Port;
    @Value("${redis.node.password:null}")
    private String password;
    @Value("${redis.connection_timeout:2000}")
    private int connectionTimeout;
    @Value("${redis.so_timeout:2000}")
    private int soTimeout;
    @Value("${redis.max_attempts:10}")
    private int maxAttempts;
    @Value("${redis.pool.maxTotal:800}")
    private int maxTotal;
    @Value("${redis.pool.minIdle:50}")
    private int minIdle;
    @Value("${redis.pool.maxIdle:200}")
    private int maxIdle;
    @Value("${redis.pool.maxWait:3000}")
    private int maxWaitMillis;

    @Bean
    public JedisCluster jedisCluster() {
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        if (!node1Ip.equals("127.0.0.1") && !(node1Port == 0)){
            nodes.add(new HostAndPort(node1Ip, node1Port));
        }
        if (!node2Ip.equals("127.0.0.1") && !(node2Port == 0)){
            nodes.add(new HostAndPort(node2Ip, node2Port));
        }
        if (!node3Ip.equals("127.0.0.1") && !(node3Port == 0)){
            nodes.add(new HostAndPort(node3Ip, node3Port));
        }

        JedisCluster jedisCluster = null;
        if (!nodes.isEmpty()){
            GenericObjectPoolConfig pool = new GenericObjectPoolConfig();
            pool.setMaxTotal(maxTotal);
            pool.setMinIdle(minIdle);
            pool.setMaxIdle(maxIdle);
            pool.setMaxWaitMillis(maxWaitMillis);
            jedisCluster =
                    new JedisCluster(nodes, connectionTimeout, soTimeout, maxAttempts, password, pool);
        }
        return jedisCluster;
    }
}

之前有说过因为所有的项目都会依赖我的基础包，但又不是所有的项目都会去配置redis。所以有了上面的设置默认值 然后判断ip是否被修改，如果被修改了说明配置的redis相关配置则有了后续的操作。相对比较灵活一点了，同时支持了生产环境测试环境机器数量不一样的情况。

如何使用？

• 在需要使用redis的相关业务项目上新增如下配置

#redis
redis.connection_timeout=2000
redis.max_attempts=10
redis.pool.maxIdle=200
redis.pool.maxTotal=800
redis.pool.maxWait=3000
redis.pool.minIdle=50
redis.so_timeout=2000
redis.node.password=redisPassword
redis.node1.ip=127.0.0.1
redis.node1.port=8000
redis.node2.ip= 127.0.0.1
redis.node2.port= 8001
redis.node3.ip= 127.0.0.1
redis.node3.port= 8002

• 然后就可以愉快的玩耍了

package com.xxx.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisCluster;

import javax.annotation.PostConstruct;

@Component
public class RedisTest {

    private static final Logger log = LoggerFactory.getLogger(RedisTest.class);


    @Autowired
    private JedisCluster jedisCluster;
    /**
     * redis key前缀
     */
    public final static String PREFIX = "token:user:";

    @PostConstruct
    public void init() {
        log.info("init  redis    jedisCommands -------------");
        String token = "hjyqakteqxpfy6431045747319394309";
        jedisCluster.set(PREFIX+token,"1000");
        String value = jedisCluster.get(PREFIX+token);
        log.info("jedisCommands.get(\"test\") = {}------------", value);
        Long del = jedisCluster.del(PREFIX+token);
        log.info("jedisCommands.get(\"test\") = {}--del-{}----------", jedisCluster.get(PREFIX+token), del);
        //设置失效时长
        jedisCluster.setex(PREFIX+token,60,"1000");
    }
}

• 当然如果你需要用到分布式锁那么往下看

package com.xxx.redis;

import com.xxx.util.redis.SimpleLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisCluster;

import javax.annotation.PostConstruct;

@Component
public class RedisTest {

    private static final Logger log = LoggerFactory.getLogger(RedisTest.class);


    @Autowired
    private JedisCluster jedisCluster;
    /**
     * redis key前缀
     */
    public final static String PREFIX = "token:user:";

    @PostConstruct
    public void init() throws Exception{

        new SimpleLock("redisKey:test",jedisCluster).wrap(new Runnable() {
            @Override
            public void run() {
                log.info("init  redis    jedisCommands -------------");
                String token = "hjyqakteqxpfy6431045747319394309";
                jedisCluster.set(PREFIX+token,"1000");
                String value = jedisCluster.get(PREFIX+token);
                log.info("jedisCommands.get(\"test\") = {}------------", value);
                Long del = jedisCluster.del(PREFIX+token);
                log.info("jedisCommands.get(\"test\") = {}--del-{}----------", jedisCluster.get(PREFIX+token), del);
                //设置失效时长
                jedisCluster.setex(PREFIX+token,60,"1000");
            }
        });
    }
}

本文为博主原创文章，转载请注明出处。谢谢！