Redis分布式缓存&分布式锁

1.背景

         由于业务需求最近准备将系统中原有的memcached改造为Redis，实现多数据类型的分布式缓存。

2.分布式缓存：

  

3.集成改造

1)       Pom依赖 vcsp-genericProfessionServerpom.xml

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
   <version>2.4.2</version>
</dependency>
<dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-redis</artifactId>
   <version>1.7.10.RELEASE</version>
</dependency>
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>2.8.1</version>
</dependency>

2)       application-*.properties

#redis配置*********************
spring.redis.hostName=192.168.1.123
spring.redis.port=6739
# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=2123
# 连接池最大连接数（使用负值表示没有限制）
# 连接超时时间（毫秒）
spring.redis.timeout=5000
spring.redis.pool.max-active= 3000
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=5000
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=1000
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=200
spring.session.store-type=none
#redis配置*********************

3)       RedisConfiguration 

@Configuration
public class RedisConfiguration{
    @Value("${spring.redis.hostName}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.pool.max-wait}")
    private long maxWaitMillis;

    @Value("${spring.redis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.password}")
    private String password;
。。。。。。。。

4)       MyRedisPool

@Component
public class MyRedisPool {

    private static final Logger LOGGER = Logger.getLogger(MyRedisPool.class);

    private static String host;

    private static int port;

    private static int timeout;

    private static int maxIdle;

    private static long maxWaitMillis;

    private static int maxActive;

    private static String password;

    @Autowired
    RedisConfiguration redisConfiguration;

    //@PostConstruct
    public void iniProperties(){
        sm4ScretKey= sm4ScretKeyUtils.getSm4ScretKey(redisConfiguration.getFileServerIntranetHost());
        host=redisConfiguration.getHost();
        port=redisConfiguration.getPort();
        timeout=redisConfiguration.getTimeout();
        maxIdle=redisConfiguration.getMaxIdle();
        maxWaitMillis=redisConfiguration.getMaxWaitMillis();
        maxActive=redisConfiguration.getMaxActive();
        password=redisConfiguration.getPassword();

        if(jedisPool==null){
            initJedisPool();
        }
        LOGGER.warn("初始化 jedisPool................");
    }

    private static JedisPool jedisPool = null;

    public static void initJedisPool(){
        try{
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);//最大空闲连接数
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);//最大等待时间
            jedisPoolConfig.setMaxTotal(maxActive);//最大活动线程数
            LOGGER.error("初始化redis线程池工厂....................host:"+host+";port:"+port+";password:"+password+";maxActive:"+maxActive);
            jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,password);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 获取Jedis实例
     *
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if(jedisPool==null){
                initJedisPool();
            }
            return jedisPool.getResource();
        } catch (Exception e) {
            jedisPool.close();
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 释放jedis资源
     *
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResourceObject(jedis);
        }
    }

    /**
     * 销毁jedis连接
     *
     * @param jedis
     */
    public static void returnBrokenResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnBrokenResource(jedis);
        }
    }
}

5)       RedisClient

/**
 * @author
 */
public class RedisClient {

    private volatile static RedisClient instance;
    private static final Logger LOGGER = Logger.getLogger(RedisClient.class);

    private RedisClient() {
    }

    public static RedisClient getInstance() {
        if (instance == null) {
            synchronized (RedisClient.class) {
                if (instance == null) {
                    instance = new RedisClient();
                }
            }
        }
        return instance;
    }

    /**
     * 自定义设置key
     *
     * @param key      键
     * @param value    值
     * @param exits    NX/XX 值只能取NX或者XX，如果取NX，则只有当key不存在是才进行set，如果取XX，则只有当key已经存在时才进行set
     * @param expx     EX/PX   值只能取EX或者PX，代表数据过期时间的单位，EX代表秒，PX代表毫秒
     * @param interval 过期时间，单位是expx所代表的单位。
     * @return SET 在设置操作成功完成时，才返回 OK 。
     * 如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）
     */
    public String set(String key, Object value, String exits, String expx, long interval) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            result = jedis.set(key, String.valueOf(value), exits, expx, interval);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置key
     * 需要传入key是否已经存在
     *
     * @param key      键
     * @param value    值
     * @param expx     EX/PX   值只能取EX或者PX，代表数据过期时间的单位，EX代表秒，PX代表毫秒
     * @param interval 过期时间，单位是expx所代表的单位。
     * @return SET 在设置操作成功完成时，才返回 OK 。
     * 如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）
     */
    public String setXX(String key, Object value, String expx, long interval) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            result = jedis.set(key, String.valueOf(value), "XX", expx, interval);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置key
     * 需要传入key是否不存存在
     *
     * @param key      键
     * @param value    值
     * @param expx     EX/PX   值只能取EX或者PX，代表数据过期时间的单位，EX代表秒，PX代表毫秒
     * @param interval 过期时间，单位是expx所代表的单位。
     * @return SET 在设置操作成功完成时，才返回 OK 。
     * 如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）
     */
    public String setNX(String key, Object value, String expx, long interval) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            result = jedis.set(key, String.valueOf(value), "NX", expx, interval);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设将字符串值 value 关联到 key 。
     * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
     *
     * @param key   键
     * @param value 值
     * @return SET 在设置操作成功完成时，才返回 OK 。
     */
    public String set(String key, Object value) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            result = jedis.set(key, String.valueOf(value));
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设将字符串值 value 关联到 key 。
     * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
     *
     * @param key   键
     * @param value 值
     * @return SET 在设置操作成功完成时，才返回 OK 。
     */
    public String set(String key, Object value, int interval) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            result = jedis.set(key, String.valueOf(value));
            expire(key, interval);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 返回 key 所关联的字符串值
     * 如果 key 不存在那么返回特殊值 nil 。
     *
     * @param key
     * @return 当 key 不存在时，返回 nil ，否则，返回 key 的值。
     * 如果 key 不是字符串类型，那么返回一个错误。
     */
    public Object get(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Object o = null;
        try {
            o = jedis.get(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return o;
    }

    public List<Map<String,String>> getListBykey(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        List<Map<String,String>> list=new ArrayList<>();
        try {
            Set<String> set  = jedis.keys(key+"*");
            for (String key1 : set){
                String value1 =String.valueOf(jedis.get(key1));
                Map<String,String> map=new HashMap<>();
                map.put(key1,value1);
                list.add(map);
            }
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 检查给定 key 是否存在。
     *
     * @param key 键
     * @return 若 key 存在，返回 true ，否则返回 false
     */
    public boolean exists(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        boolean flag = false;
        try {
            flag = jedis.exists(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 判断是否存在，存在则返回对象，不存在返回null
     *
     * @param key
     * @return 若 key 存在，返回 1 ，否则返回 0 。
     */
    public Object retExists(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Object o = null;
        try {
            if (jedis.exists(key)) {
                o = jedis.get(key);
            }
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return o;
    }

    /**
     * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
     * 可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。
     *
     * @param key
     * @return 设置成功返回 1 。
     * 当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。
     */
    public Long expire(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.expire(key, -1);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
     * 可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。
     *
     * @param key
     * @param interval
     * @return 设置成功返回 1 。
     * 当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。
     */
    public Long expire(String key, int interval) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.expire(key, interval);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
     *
     * @param key
     * @return 当生存时间移除成功时，返回 1 .
     * 如果 key 不存在或 key 没有设置生存时间，返回 0 。
     */
    public Long persist(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.persist(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 删除给定的一个或多个 key 。
     * 不存在的 key 会被忽略。
     *
     * @param key 键
     * @return 被删除 key 的数量。
     */
    public Long delete(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.del(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
     * 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
     *
     * @param key    键
     * @param score  分数
     * @param member 值
     * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
     */
    public Long zadd(String key, double score, String member) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.zadd(key, score, member);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
     * 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
     *
     * @param key    键
     * @param member 值
     * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
     */
    public Long zadd(String key, String member) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.zadd(key, System.currentTimeMillis(), member);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 获取该key总数(全部)
     *
     * @param key
     * @return score 值在 min 和 max 之间的成员的数量
     */
    public Long zcount(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long count = 0L;
        try {
            count = jedis.zcount(key, "-inf", "+inf");
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return count;
    }

    /**
     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
     *
     * @param key 键
     * @param min 最小值
     * @param max 最大值
     * @return score 值在 min 和 max 之间的成员的数量
     */
    public Long zcount(String key, double min, double max) {
        Jedis jedis = MyRedisPool.getJedis();
        Long count = 0L;
        try {
            count = jedis.zcount(key, min, max);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return count;
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     * 其中成员的位置按 score 值递增(从小到大)来排序。
     * 超出范围的下标并不会引起错误。
     *
     * @param key   键
     * @param start 开始分数
     * @param end   结束分数
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrange(String key, long start, long end) {
        Jedis jedis = MyRedisPool.getJedis();
        Set<String> list = null;
        try {
            list = jedis.zrange(key, start, end);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 设置 key 指定的哈希集中指定字段的值。
     * 如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联。
     * 如果字段在哈希集中存在，它将被重写。
     *
     * @param key
     * @param field
     * @param value
     * @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
     * 如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
     */
    public Long hset(String key, String field, String value) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.hset(key, field, value);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置 key 指定的哈希集中指定字段的值。该命令将重写所有在哈希集中存在的字段。
     * 如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联
     *
     * @param key
     * @param maps
     * @return 如果命令执行成功，返回 OK 。
     * 当 key 不是哈希表(hash)类型时，返回一个错误。
     */
    public String hmset(String key, Map<String, String> maps) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = "";
        try {
            if (maps == null) {
                throw new NullPointerException("maps为空!");
            }
            if (!maps.isEmpty()) {
                result = jedis.hmset(key, maps);
            }
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 返回 key 指定的哈希集中所有的字段和值。
     *
     * @param key
     * @return 以列表形式返回哈希表的域和域的值。
     * 若 key 不存在，返回空列表。
     */
    public Map<String, String> hgetAll(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Map<String, String> map = null;
        try {
            map = jedis.hgetAll(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 对存储在指定key的数值执行原子的加1操作。
     * 如果指定的key不存在，那么在执行incr操作之前，会先将它的值设定为0。
     *
     * @param key
     * @return 执行 INCR 命令之后 key 的值
     */
    public Long incr(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.incr(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 对key对应的数字做减1操作。如果key不存在，那么在操作之前，这个key对应的值会被置为0。
     * 如果key有一个错误类型的value或者是一个不能表示成数字的字符串，就返回错误。
     *
     * @param key
     * @return 执行 DECR 命令之后 key 的值。
     */
    public Long decr(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.decr(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
     * 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
     * 当 key 不是集合类型时，返回一个错误。
     *
     * @param key
     * @param members
     * @return 被添加到集合中的新元素的数量，不包括被忽略的元素
     */
    public Long sadd(String key, String members) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.sadd(key, members);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 返回集合 key 的基数(集合中元素的数量)。
     *
     * @param key
     * @return 集合的基数。当 key 不存在时，返回 0 。
     */
    public Long scard(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.scard(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 返回集合 key 中的所有成员。不存在的 key 被视为空集合。
     *
     * @param key
     * @return 集合中的所有成员。
     */
    public Set<String> smembers(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Set<String> set = null;
        try {
            set = jedis.smembers(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return set;
    }

    /**
     * 判断 member 元素是否集合 key 的成员。
     *
     * @param key
     * @return 如果 member 元素是集合的成员，返回 1 。
     * 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。
     */
    public Boolean sismember(String key, String members) {
        Jedis jedis = MyRedisPool.getJedis();
        Boolean result = false;
        try {
            result = jedis.sismember(key, members);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
     *
     * @param key
     * @return 被成功移除的元素的数量，不包括被忽略的元素。
     */
    public Long srem(String key, String members) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.srem(key, members);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集。
     * 但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 集合已经存在，则将其覆盖。
     *
     * @param dstkey
     * @param key
     * @return 结果集中的元素数量。
     */
    public Long sdiffstore(String dstkey, String key) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.sdiffstore(dstkey, key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }

    //从队列中左侧进入一个元素
    public Long lpush(String key, String value) {
        Jedis jedis = MyRedisPool.getJedis();
        Long result = 0L;
        try {
            result = jedis.lpush(key,value);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }
    //从队列中右侧出一个元素
    public String rpop(String key) {
        Jedis jedis = MyRedisPool.getJedis();
        String result = null;
        try {
            result = jedis.rpop(key);
            MyRedisPool.returnResource(jedis);
        } catch (Exception e) {
            MyRedisPool.returnBrokenResource(jedis);
            e.printStackTrace();
        }
        return result;
    }






    /*******************分布式锁******************/
    public boolean lock(String key, int exprie) {
        try {
            exprie = exprie <= 0 ? 60 : exprie;
            String value = JsonUtil2.obj2String(createMeta(exprie));
            String lockKey = this.getLockKeyPrev() + key;
            String result=this.setNX(lockKey, value,"EX",exprie);
            if (result!=null && result.equals("OK")) {
                LOGGER.info("Get redis lock success, key =" + lockKey);
                return true;
            }
            Object obj = this.get(lockKey);
            if (obj==null) {
                this.delete(lockKey);
                LOGGER.info("Redis unlock success ,key = " + lockKey);
                Thread.sleep(1000);
                value = JsonUtil2.obj2String(createMeta(exprie));
                String result1=this.setNX(lockKey, value,"EX",exprie);
                if (result1!=null && result1.equals("OK")) {
                    this.expire(lockKey, exprie);
                    LOGGER.info("Get redis lock success, key =" + lockKey);
                    return true;
                } else {
                    LOGGER.warn("Get redis lock fail, key =" + lockKey);
                    return false;
                }
            }
            value = (String)obj;
            LockModel model = JsonUtil2.getObjectMapper().readValue(value, LockModel.class);
            if (model.isLose()) {// 已经超时
                this.delete(lockKey);
                value = JsonUtil2.obj2String(createMeta(exprie));
                String result2=this.setNX(lockKey, value,"EX",exprie);
                if (result2!=null && result2.equals("OK")) {
                    this.expire(lockKey, exprie);
                    LOGGER.info("Get redis lock success, key =" + lockKey);
                    return true;
                } else {
                    LOGGER.warn("Get redis lock fail, key =" + lockKey);
                    return false;
                }
            }
            LOGGER.warn("Get redis lock fail, key =" + lockKey);
            return false;
        } catch (Exception ex) {
            ex.printStackTrace();
            LOGGER.error(ex.getMessage());
            return true;
        }
    }

    public void unlock(String key) {
        String lockKey = this.getLockKeyPrev() + key;
        try {
            delete(lockKey);
        } catch (Exception ex) {
            LOGGER.error(ex.getMessage());
        }
        LOGGER.info("Redis unlock success ,key = " + lockKey);
    }

    private LockModel createMeta(int exprie) {
        LockModel meta = new LockModel();
        meta.setExpireTime(exprie);
        meta.setLockTime(System.currentTimeMillis());
        return meta;
    }

    public String getLockKeyPrev() {
        return "lock:";
    }
    /*******************分布式锁******************/

4.Redis分布式锁

1.基于redis的setnx 命令实现分布式锁

2.lua脚本结合redis命令可以实现原子性（Redis 服务器会单线程原子性执行 lua 脚本，保证 lua 脚本在处理的过程中不会被任意其它请求打断）

代码使用样例：

 try {
        boolean isLock= RedisClient.getInstance().lock(TASK_NAME,30);
        if (!isLock){
            return;
        }
        handle();
    } catch (Exception e) {
        log.error("error: e=" + e.getMessage());
    } finally {
        RedisClient.getInstance().unlock(TASK_NAME);
    }