redis分布式锁jedis--lua锁的使用

最新推荐文章于 2023-12-19 23:12:49 发布
最新推荐文章于 2023-12-19 23:12:49 发布
阅读量603 收藏
点赞数
分类专栏： 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43318174/article/details/118608223
版权

依赖

  <!-- Redis客户端 start -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.9.0</version>
</dependency>

controller

 /**
     * 车主端 确认支付
     *
     * @param requestDto
     * @param rpcPacket
     * @return
     */
    @UrlMapping(url = "carOwner/confirmPayment")
    public RpcPacket changeConfirmPaymentForCarOwner(RpcCarOwnerConfirmPaymentReqDto requestDto, RpcPacket rpcPacket) {
        logger.info("车主端 确认支付,requestDto {},rpcPacket {}", JsonUtil.toJson(requestDto), JsonUtil.toJson(rpcPacket));
        RpcPacket packet = new RpcPacket();
        String lockKey = OrderServiceModulConstant.LOCK_CAROWNER_COMFIRM_PAY_LOKENAME + requestDto.getOrderId();
        String lockName = "";
        try {
            //先分布锁一下 订单
            lockName = redisCache.getLockLua(lockKey, OrderServiceModulConstant.LOCK_CAROWNER_COMFIRM_PAY_EXPIRETIME, OrderServiceModulConstant.LOCK_CAROWNER_COMFIRM_PAY_TIMEOUT);
            if (!StringUtil.isEmpty(lockName)) {
                Long oldCouponId = orderFeeService.updateBindCounpByOrderId(requestDto);
//                if (oldCouponId!=null) {
//                    rpcServie.updateUnBindCouponByCouponId(oldCouponId);
//                }
                RpcCarOwnComfirmPayRetDto res = orderFeeService.changeConfirmPaymentForCarOwner(requestDto, rpcPacket);
                packet.setData(res);
                if (res != null) {
                    switch (res.getStatus()) {
                        case 1:
                            packet.setAnwserCode(new AnwserCode(1, "车主端 支付成功"));
                            break;
                        case 2:
                            packet.setAnwserCode(new AnwserCode(1, "车主端 请调起三方支付"));
                            break;
                        case 3:
                            packet.setAnwserCode(new AnwserCode(-2, "车主端 支付失败"));
                            break;
                    }
                }
            } else {
                throw new ArgsException("支付处理中，请勿重复提交");
            }
        } catch (ArgsException e) {
            logger.error("车主端 确认支付异常 {}", e.toString());
            packet.setAnwserCode(e.getAnwserCode());
        } catch (Exception e) {
            logger.error("车主端 确认支付异常 {}", e.toString());
            packet.setAnwserCode(OrderServiceAnwserCode.BUSS_ERROR_CALCULPAYMENT_CAROWNER);
        } finally {
            redisCache.releaseLock(lockKey, lockName);
        }
        logger.info("车主端 确认支付,packet {}", JsonUtil.toJson(packet));
        return packet;
    }

RedisCache

package com.wanshun.common.database.redis;

import com.wanshun.common.utils.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.*;
import redis.clients.jedis.exceptions.JedisException;
import redis.clients.jedis.params.geo.GeoRadiusParam;

import java.io.IOException;
import java.util.*;

public class RedisCache {
    private final static Logger logger = LoggerFactory.getLogger(RedisCache.class);

    private JedisCluster jedisCluster;

    private String prefixKey;

    @Autowired
    private RedisConfig redisConfig;

    public RedisCache(String prefixKey, RedisConfig redisConfig) {
        this.prefixKey = prefixKey + "_";
        this.redisConfig = redisConfig;

        this.init();
    }

    public void init() {
        if (null == jedisCluster) {
            if (StringUtil.isEmpty(prefixKey) || prefixKey.length() <= 1) {
                logger.error("初始化redisCache失败，该模块的redis的key为空");

                System.exit(0);
            }
            synchronized (RedisCache.class) {
                if (null == jedisCluster) {

                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setTestOnReturn(true);

                    Set<HostAndPort> shardInfoList = new HashSet<HostAndPort>();

                    try {

                        poolConfig.setMaxIdle(redisConfig.getMaxIdle());
                        poolConfig.setMinIdle(redisConfig.getMinIdle());
                        poolConfig.setTestOnReturn(redisConfig.getTestOnReturn());
                        poolConfig.setTestOnBorrow(redisConfig.getTestOnBorrow());

                        String[] shardedList = redisConfig.getShared().split(";");
                        for (String server : shardedList) {
                            String[] values = server.split(":");
                            HostAndPort node = new HostAndPort(values[0], Integer.parseInt(values[1]));
                            shardInfoList.add(node);
                        }

                        Integer timeout = redisConfig.getTimeout() == null ? 2000 : redisConfig.getTimeout();

                        String password = redisConfig.getPassword();

                        Integer maxactive = redisConfig.getMaxActive();

                        if (StringUtil.isNullOrBlank(password)) {
                            jedisCluster = new JedisCluster(shardInfoList, timeout, timeout, maxactive, poolConfig);
                        } else {
                            jedisCluster = new JedisCluster(shardInfoList, timeout, timeout, maxactive, password, poolConfig);
                        }

                    } catch (Exception e) {
                        logger.error("getShardedJedisPool", e);

                        jedisCluster = null;

                        throw e;
                    }
                }
            }
        }
    }

    public String getSet(String key, String value) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.getSet(realKey, value);
        } catch (Exception e) {
            throw e;
        }
    }

    public Boolean exists(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.exists(realKey);
        } catch (Exception e) {
            throw e;
        }
    }

    public Boolean deleteKey(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.del(realKey) > 0;
        } catch (Exception e) {
            throw e;
        }
    }

    public void deleteKeyNoPrefixKey(String key) {
        try {
            jedisCluster.del(key);
        } catch (Exception e) {
            throw e;
        }
    }

    public Boolean deleteKeyNoPrefix(String key) {
        try {
            return jedisCluster.del(key) > 0;
        } catch (Exception e) {
            throw e;
        }
    }

    public boolean set(String key, String value, Integer seconds) {
        String realKey = this.prefixKey + key;
        try {
            jedisCluster.setex(realKey, seconds, value);
            return true;
        } catch (Exception e) {
            throw e;
        }
    }

    public boolean setnoexpire(String key, String value) {
        String realKey = this.prefixKey + key;
        try {
            jedisCluster.set(realKey, value);
            return true;
        } catch (Exception e) {
            throw e;
        }
    }

    public String get(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.get(realKey);
        } catch (Exception e) {
            return null;
        }
    }

    public Long ttl(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.ttl(realKey);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 删除缓存
     *
     * @param key
     * @return
     */
    public boolean remove(String key) {
        String realKey = this.prefixKey + key;
        return deleteKey(realKey);
    }

    /**
     * 设置可以的过期时间
     *
     * @param key
     * @param seconds
     */
    public boolean cacheExpire(String key, Integer seconds) {
        String realKey = this.prefixKey + key;
        try {
            jedisCluster.expire(realKey, seconds);
            return true;
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 获取序列化对象
     *
     * @param key
     * @return
     */
    public byte[] get(byte[] key) {
        String realKey = this.prefixKey + new String(key);
        try {
            return jedisCluster.get(realKey).getBytes();
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 自增一
     *
     * @param key
     * @return 自增后的值
     */
    public Long incr(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.incr(realKey);
        } catch (Exception e) {
            throw e;
        }
    }

    public Long incrBy(String key, long integer) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.incrBy(realKey, integer);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 自减一
     *
     * @param key
     * @return 自减后的值
     */
    public Long decr(String key) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.decr(realKey);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 自减特定步长
     *
     * @param key
     * @param integer
     * @return 自减后的值
     */
    public Long decrBy(String key, long integer) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.decrBy(realKey, integer);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 新建LIST
     *
     * @param key
     * @param index
     * @param value
     * @return
     */
    public boolean setList(String key, Long index, String value) {
        String realKey = this.prefixKey + key;
        if (value == null) {
            return false;
        }
        try {
            jedisCluster.lset(realKey, index, value);
            return true;

        } catch (Exception e) {
            throw e;
        }
    }


    /**
     * 设置hash 字段-值
     *
     * @param key   键
     * @param field 字段
     * @param value 值
     * @return
     */
    public boolean setHash(String key, String field, String value) {
        String realKey = this.prefixKey + key;

        if (value == null) {
            return false;
        }

        try {
            jedisCluster.hset(realKey, field, value);
            return true;

        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 获得HashSet对象
     *
     * @param key   键
     * @param field 字段
     * @return Json String or String value
     */
    public String getHash(String key, String field) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.hget(realKey, field);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 存储 map
     *
     * @param key
     * @param map
     * @return
     */
    public boolean hmset(String key, Map<String, String> map) {
        String realKey = this.prefixKey + key;

        try {
            jedisCluster.hmset(realKey, map);
            return true;
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * @param key
     * @param fields
     * @return
     */
    public List<String> hmget(String key, String... fields) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.hmget(realKey, fields);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 删除Hash 字段对象
     *
     * @param key   键
     * @param field 字段
     * @return 删除的记录数
     */
    public long delHash(String key, String field) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.hdel(realKey, field);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 删除Hash 多个字段对象
     *
     * @param key   键值
     * @param field 字段
     * @return 删除的记录数
     */
    public long delHash(String key, String... field) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.hdel(realKey, field);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 判断key下的field是否存在
     *
     * @param key   键
     * @param field 字段
     * @return
     */
    public boolean existsHash(String key, String field) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.hexists(realKey, field);

        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 返回 key 指定的哈希集中所有字段的value值
     *
     * @param key
     * @return
     */

    public List<String> hvals(String key) {
        String realKey = this.prefixKey + key;
        try {

            return jedisCluster.hvals(realKey);
        } catch (Exception e) {

            throw e;
        }
    }

    public Set<String> hkeys(String key) {
        String realKey = this.prefixKey + key;
        try {

            return jedisCluster.hkeys(realKey);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * 返回 key指定的字段值总数
     *
     * @param key
     * @return
     */
    public long lenHash(String key) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.hlen(realKey);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * list 添加
     *
     * @param key
     * @param strings
     */
    public Long lpush(String key, String... strings) {
        String realKey = this.prefixKey + key;
        return jedisCluster.lpush(realKey, strings);
    }

    /**
     * list 获取长度
     */
    public long llen(String key) {
        String realKey = this.prefixKey + key;

        return jedisCluster.llen(realKey);
    }

    //redis 监听消息通道===========================

    /**
     * 推入消息到redis消息通道
     *
     * @param String channel
     * @param String message
     */
    public Long publish(String channel, String message) {

        return jedisCluster.lpush(channel, message);
    }

    /**
     * 推入消息到redis消息通道
     *
     * @param byte[] channel
     * @param byte[] message
     */
    public Long publish(byte[] channel, byte[] message) {
        return jedisCluster.lpush(channel, message);
    }


    /**
     * 获取队列数据
     *
     * @param byte[] key 键名
     * @return
     */
    public byte[] rpop(byte[] key) {
        String realKey = new String(key);
        realKey = this.prefixKey + key;

        byte[] bytes = null;
        try {

            bytes = jedisCluster.rpop(realKey.getBytes());

        } catch (Exception e) {

            //释放redis对象
            e.printStackTrace();

        }
        return bytes;
    }

    /**
     * 获取队列数据
     *
     * @param byte[] key 键名
     * @return
     */
    public String rpop(String key) {
        String realKey = this.prefixKey + key;

        String bytes = null;
        try {

            bytes = jedisCluster.rpop(realKey);

        } catch (Exception e) {

            //释放redis对象
            e.printStackTrace();

        }
        return bytes;
    }

    /**
     * 监听消息通道
     *
     * @param jedisPubSub - 监听任务
     * @param channels    - 要监听的消息通道
     * @throws IOException
     */
    public void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels) throws IOException {

        try {

            jedisCluster.subscribe(jedisPubSub, channels);

        } catch (Exception e) {

            throw e;
        } finally {
            jedisCluster.close();
        }
    }

    /**
     * 监听消息通道
     *
     * @param jedisPubSub - 监听任务
     * @param channels    - 要监听的消息通道
     * @throws IOException
     */
    public void subscribe(JedisPubSub jedisPubSub, String... channels) throws IOException {
        try {

            jedisCluster.subscribe(jedisPubSub, channels);
        } catch (Exception e) {

            throw e;
        } finally {
            jedisCluster.close();
        }
    }

    //redis 监听消息通道===========================

    /**
     * 删除指定元素
     *
     * @param key
     * @param count
     * @param value
     */
    public boolean lrem(String key, int count, String value) {
        String realKey = this.prefixKey + key;

        try {
            jedisCluster.lrem(realKey, count, value);
            return true;
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * list 指定元素 0，-1 所有
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<String> lrange(String key, int start, int end) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.lrange(realKey, start, end);

        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * add string to set
     *
     * @param key
     * @param members
     */
    public boolean sadd(String key, String... members) {
        String realKey = this.prefixKey + key;

        try {
            jedisCluster.sadd(realKey, members);
            return true;
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * exists value
     *
     * @param key
     * @param member
     * @return
     */
    public boolean sismember(String key, String member) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.sismember(realKey, member);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * select all
     *
     * @param key
     * @return
     */
    public Set<String> smembers(String key) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.smembers(realKey);
        } catch (Exception e) {

            throw e;
        }
    }

    /**
     * delete value in set
     *
     * @param key
     * @param value
     */
    public boolean srem(String key, String value) {
        String realKey = this.prefixKey + key;

        try {
            return jedisCluster.srem(realKey, value) > 0;

        } catch (Exception e) {

            throw e;
        }
    }

    public String ltrim(String key, int start, int end) {
        try {
            return jedisCluster.ltrim(this.prefixKey + key, start, end);
        } catch (Exception e) {
            throw e;
        }
    }

    public Set<String> zrevrange(String key, long start, long end) {
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.zrevrange(realKey, start, end);
        } catch (Exception e) {
            throw e;
        }
    }

    public boolean setNx(String key, String obj, int seconds) {
        Long result;
        try {
            result = jedisCluster.setnx(key, obj);
            if (result == 1) {
                jedisCluster.expire(key, seconds);
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
        }
        return false;
    }

    public Long zadd(String key, Long score, String value) {
        String realKey = this.prefixKey + key;
        Long result = 0L;
        try {
            result = jedisCluster.zadd(realKey, score.doubleValue(), value);
        } catch (Exception e) {
        }
        return result;
    }

    /**
     * 分页获取ZSET数据
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Tuple> zrevrangeWithScores(String key, long start, long end) {
        logger.info("RedisCache zrange key={},start={},end={}", key, start, end);
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.zrevrangeWithScores(realKey, start, end);
        } catch (Exception e) {
            logger.error("RedisCache zrange key={},start={},end={},e={}", realKey, start, end, e);
        }
        return Collections.emptySet();
    }

    /**
     * 获取对应元素的排名
     *
     * @param key
     * @param member
     * @return
     */
    public Long zrevrank(String key, String member) {
        logger.info("RedisCache zrevrank key={},member={}", key, member);
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.zrevrank(realKey, member);
        } catch (Exception e) {
            logger.error("RedisCache zrevrank key={},member={},e ={}", key, member, e);
        }
        return -1L;
    }

    /**
     * 获取对应元素的分数
     *
     * @param key
     * @param member
     * @return
     */
    public Double zscore(String key, String member) {
        logger.info("RedisCache zscore key={},member={}", key, member);
        String realKey = this.prefixKey + key;
        try {
            return jedisCluster.zscore(realKey, member);
        } catch (Exception e) {
            logger.error("RedisCache zscore key={},member={},e ={}", key, member, e);
        }
        return 0.00;
    }


    public Long zrem(String key, String value) {
        String realKey = this.prefixKey + key;
        Long result = 0L;
        try {
            result = jedisCluster.zrem(realKey, value);
        } catch (Exception e) {
        }
        return result;
    }

    /**
     * 加锁
     *
     * @param key            锁的key
     * @param acquireTimeout 获取超时时间
     * @param timeout        锁的超时时间
     * @return 锁标识
     */
    public String lockWithTimeout(String key, long acquireTimeout, long timeout) {
        String retIdentifier = null;
        try {
            // 随机生成一个value
            String identifier = UUID.randomUUID().toString();

            // 超时时间，上锁后超过此时间则自动释放锁
            int lockExpire = (int) (timeout / 1000);

            // 获取锁的超时时间，超过这个时间则放弃获取锁
            long end = System.currentTimeMillis() + acquireTimeout;
            while (System.currentTimeMillis() < end) {
                if (jedisCluster.setnx(key, identifier) == 1) {
                    jedisCluster.expire(key, lockExpire);
                    // 返回value值，用于释放锁时间确认
                    retIdentifier = identifier;
                    return retIdentifier;
                }
                // 返回-1代表key没有设置超时时间，为key设置一个超时时间
                if (jedisCluster.ttl(key) == -1) {
                    jedisCluster.expire(key, lockExpire);
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        } catch (JedisException e) {
            throw e;
        }
        return retIdentifier;
    }

    /**
     * 加锁
     * 运用lua脚本
     *
     * @param key            锁的key
     * @param acquireTimeout 获取超时时间
     * @param timeout        锁的超时时间
     * @return 锁标识
     */
    public String getLockLua(String key, long acquireTimeout, long timeout) {
        return getLockLua(key, timeout);
    }

    public String getLockLua(String key, long timeout) {
        List<String> keys = new ArrayList<>();
        int lockExpire = (int) (timeout / 1000);
        keys.add(key);
        List<String> args = new ArrayList<>();
        args.add(lockExpire + "");
        args.add(UUID.randomUUID().toString());
        return "OK".equals(jedisCluster.eval("return redis.call('set', KEYS[1],ARGV[2],'nx', 'ex', ARGV[1]) ", keys, args)) ? args.get(1) : "";
    }

    public String getLock(String key, long timeout) {
        String retIdentifier = null;
        try {
            // 随机生成一个value
            String identifier = UUID.randomUUID().toString();

            // 超时时间，上锁后超过此时间则自动释放锁
            int lockExpire = (int) (timeout / 1000);

            if (jedisCluster.setnx(key, identifier) == 1) {
                jedisCluster.expire(key, lockExpire);
                // 返回value值，用于释放锁时间确认
                retIdentifier = identifier;
                return retIdentifier;
            }
            // 返回-1代表key没有设置超时时间，为key设置一个超时时间
            if (jedisCluster.ttl(key) == -1) {
                jedisCluster.expire(key, lockExpire);
            }
        } catch (JedisException e) {
            throw e;
        }
        return retIdentifier;
    }

    /**
     * 释放锁
     *
     * @param key        锁的key
     * @param identifier 释放锁的标识
     * @return
     */
    public boolean releaseLock(String key, String identifier) {
        boolean retFlag = false;
        try {
            // 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁
            if (identifier.equals(jedisCluster.get(key))) {
                jedisCluster.del(key);
                retFlag = true;
            }
        } catch (JedisException e) {
            throw e;
        }
        return retFlag;
    }

    public Set<String> keys(String pattern) {
        HashSet<String> keys = new HashSet<String>();

        Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes();
        for (String node : clusterNodes.keySet()) {
            JedisPool jp = clusterNodes.get(node);
            Jedis connection = jp.getResource();
            try {
                keys.addAll(connection.keys(pattern));
            } catch (Exception e) {

            } finally {
                connection.close();
            }
        }

        return keys;
    }

    //订单开始坐标存入redis
    public Long addReo(double lon, double lat, String orderId) {
        try {
            return jedisCluster.geoadd("orderStation", lon, lat, orderId);
        } catch (Exception e) {
            logger.error("reids 缓存坐标异常：", e);
        }
        return null;
    }

    //查询坐标系附近的订单
    public List<GeoRadiusResponse> queryReo(Double lon, Double lat, double radius) {
        try {
            return jedisCluster.georadius("orderStation", lon, lat, radius, GeoUnit.KM, GeoRadiusParam.geoRadiusParam().withDist());

        } catch (Exception e) {
            logger.error("reids 查询坐标系附近的订单异常：", e);
        }
        return null;
    }


    //redis删除订单坐标
    public Long delReo(String orderId) {
        try {
            return jedisCluster.zrem("orderStation", orderId);
        } catch (Exception e) {
            logger.error("reids 删除订单坐标异常：", e);
        }
        return null;
    }

    public JedisCluster getJedisCluster() {
        return jedisCluster;
    }
}

常量类

    /**
     * 确认支付加状态加锁
     **/
    public static final String LOCK_CAROWNER_COMFIRM_PAY_LOKENAME = orderService + "_LOCK_CAROWNE_COMFIRM_PAY:";
    public static final long LOCK_CAROWNER_COMFIRM_PAY_EXPIRETIME = 10 * 1000L;
    public static final long LOCK_CAROWNER_COMFIRM_PAY_TIMEOUT = 30 * 1000L;

redis的配置类

package com.wanshun.common.database.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("redisConfig")
public class RedisConfig {

	private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);

	private Integer maxIdle;
	private Integer minIdle;
	private Boolean testOnReturn;
	private Boolean testOnBorrow;
	private String shared;
	private Integer timeout;
	private String password;
	private Integer maxActive;


	public Integer getMaxIdle() {
		return maxIdle;
	}

	@Value("${redis.maxIdle:}")
	public void setMaxIdle(Integer maxIdle) {
		this.maxIdle = maxIdle;
	}

	public Integer getMinIdle() {
		return minIdle;
	}

	@Value("${redis.minIdle:}")
	public void setMinIdle(Integer minIdle) {
		this.minIdle = minIdle;
	}

	public Boolean getTestOnReturn() {
		return testOnReturn;
	}

	@Value("${redis.testOnReturn:}")
	public void setTestOnReturn(Boolean testOnReturn) {
		this.testOnReturn = testOnReturn;
	}

	public Boolean getTestOnBorrow() {
		return testOnBorrow;
	}

	@Value("${redis.testOnBorrow:}")
	public void setTestOnBorrow(Boolean testOnBorrow) {
		this.testOnBorrow = testOnBorrow;
	}

	public String getShared() {
		return shared;
	}

	@Value("${redis.shared:}")
	public void setShared(String shared) {
		this.shared = shared;
	}

	public Integer getTimeout() {
		return timeout;
	}

	@Value("${redis.timeout:}")
	public void setTimeout(Integer timeout) {
		this.timeout = timeout;
	}

	public String getPassword() {
		return password;
	}

	@Value("${redis.password:}")
	public void setPassword(String password) {
		this.password = password;
	}

	public Integer getMaxActive() {
		return maxActive;
	}

	@Value("${redis.maxActive:}")
	public void setMaxActive(Integer maxactive) {
		this.maxActive = maxactive;
	}

	@Override
	public String toString() {
		return "RedisConfig [maxIdle=" + maxIdle + ", minIdle=" + minIdle + ", testOnReturn=" + testOnReturn
				+ ", testOnBorrow=" + testOnBorrow + ", shared=" + shared + ", timeout=" + timeout + ", password="
				+ password + ", maxactive=" + maxActive + "]";
	}
}

//原理暂时不清楚，只是记录一下怎么写代码，稍后会补充上

流程 

1.使用jedis cluster调用lua锁，如果能获取到对应的key，证明可以用，如果不能说明在redis内存中此key已被其他线程占用

2.最后不管是程序报错还是程序结束都要释放lua锁

推荐博客：Redis分布式锁实现【精要总结】_少年单排，记录点滴 -CSDN博客

                    Redis的分布式锁详解_张维鹏的博客-CSDN博客_redis分布式锁

                   Redisson实现分布式锁(1)---原理 - 雨点的名字 - 博客园 (cnblogs.com)

                   Redisson实现Redis分布式锁的原理 - 青春暮年 - 博客园 (cnblogs.com)

                   EVAL — Redis 命令参考 (redisfans.com)

回忆是昨天里的海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是在多节点之间共享资源时，用于协调各个节点的访问控制机制。在分布式...
redis分布式锁.zip
10-18
在实际项目中，为了提高代码的健壮性和可维护性，通常会封装一个 Redis 分布式锁的客户端库，例如 Java 中的 Jedis 或 lettuce 库。这些库提供了更高级别的接口，隐藏了底层的 Redis 操作细节，使开发者更容易地使用...
Jedis简单实例、Jedis管道操作以及Lua脚本
EnjoyFight的博客
11-11 679
其中 “return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}” 是被求值的Lua脚本，数字2指定了键名参数的数量， key1和key2是键名参数，分别使用 KEYS[1] 和 KEYS[2] 访问，而最后的 first 和 second 则是附加参数，可以通过 ARGV[1] 和 ARGV[2] 访问它们。：redis自带的事务功能很鸡肋，而redis的lua脚本几乎实现了常规的事务功能，官方推荐如果要使用redis的事务功能可以用redis lua替代。
Jedis使用lua脚本完成令牌桶限流
Cocoxzq000的博客
11-26 1163
Jedis使用lua脚本完成令牌桶限流 文章目录Jedis使用lua脚本完成令牌桶限流一、lua脚本的简单语法二、令牌桶限流1. 构思2. 实现三、Jemeter压测工具测试 一、lua脚本的简单语法 KEYS[1] ARGV[1] 这两个参数分别代表了我们传入的key数组的一号元素和arg数组的一号元素 下面来看一个简单的使用 eval “return redis.call(‘get’,KEYS[1])” 1 one 首先eval 是解析Lua脚本的关键字，字符串中的就是写的lua脚本，其中 redis
redis学习(十六) 使用jedis执行lua脚本(实现一个对IP的限流)
热门推荐
文若书生的专栏
09-15 1万+
使用jedis执行lua脚本(实现一个对IP的限流) 上一篇学习了怎么安装lua，这一篇学习编写一个lua脚本用jedis执行，实现对一个IP的限流 LUA脚本如下，第一次使用incr对KEY（某个IP作为KEY）加一，如果是第一次访问，使用expire设置一个超时时间，这个超时时间作为Value第一个参数传入，如果现在递增的数目大于输入的第二个Value参数，返回失败标记，否则成功。...
Redis中使用Lua脚本实现原子操作
咖啡煮码
12-19 1362
Redis允许用户在服务器上上传并执行 Lua 脚本，也就是说Redis支持我们使用Lua编写一些简单的逻辑，当做一个自定义的命令，在单次操作中来执行，这在很多场景中都很有用，比如redisson分布式锁，滑动窗口限流等。现在就以简单例子上手来看看java编程怎么使用lua脚本实现redis原子操作。
使用 Redis 和 Lua 实现分布式锁
BXA
06-10 3864
分布式锁是一种用于多台服务器上处理同一资源的并发访问的锁机制。它用于协调分布式系统中的各个节点，确保它们的操作不会相互干扰。Redis （Remote Dictionary Server）是一种使用 C 语言编写的，开源的 in-memory 数据库系统，支持多种数据结构类型，如字符串、哈希表、列表、集合等。由于其可高效地存储键值对，并且具有多种灵活的使用方式，因此经常被用作缓存、会话存储和消息队列等场景。
单机redis分布式锁实现原理解析
08-19
单机Redis分布式锁的实现原理是通过使用Redis的SET命令和Lua脚本来实现加锁和解锁操作。 分布式锁的原则包括： 1. 互斥性：任意时刻，只有一个客户端能持有锁。 2. 不会发生死锁：即使一个客户端持有锁的期间崩溃...
jedis-2.9.0 最新版Redis客户端CSDN下载
01-08
- 分布式锁：提供基于Redis的分布式锁实现，可以跨服务进行资源锁定。 - 事件监听：允许注册监听器，监听Redis中的某些事件，如键的过期或删除。 使用Jedis进行开发的基本步骤： 1. 创建Jedis实例：`Jedis jedis = ...
springboot基于redis分布式锁
11-06
不过，以上代码提供了一个基本的实现思路，帮助你理解如何在SpringBoot应用中使用Redis实现分布式锁。 通过提供的Word文档，你应该能够找到更详细的配置和使用步骤。记得在实际项目中根据具体需求进行调整，确保...
采用lua脚本做高可用分布式锁的优化
dfBeautifulLive的博客
10-26 448
上一次博客用lua实现了分布式锁，这次来说说分布式锁在某种场景情况下会出现的问题，然后并解决。 博客地址：LUA脚本实现分布式锁 分布式锁可能会出现什么问题呢？ 假如a服务器设置锁超时时间是1分钟，这个服务器的执行任务超过锁的时间还没执行完，那么锁超时自己会释放。但是此时a服务器任务还没执行完哦 此时b进程进来执行了，发现没锁，加锁，然后b开始执行任务，那现在正好a的任务执行完了，a此时要释放锁，因为key是一样的，此时出现问题就是a把正在执行任务的b的锁给释放了，导致b处在无锁当中。 往复循
【进阶篇】2.4 Redis Lua脚本详解
日拱一卒无有尽，功不唐捐终入海
07-15 9628
Redis 其内置了脚本语言Lua，允许用户通过Lua脚本执行一系列操作。本篇博客将深入探讨Redis Lua脚本的执行机制，包括加载脚本、编译脚本和执行脚本的过程，以及脚本的原子性和事务性。我们将通过实例演示的方式，展示如何在Redis中使用Lua脚本，以及Lua脚本在Redis中的应用场景。让我们一起来了解Redis Lua脚本的强大之处吧！Lua是一种轻量级的脚本语言，它具有简洁、灵活、高效的特点。Lua语言最初是为嵌入式系统设计的，但现在已广泛应用于游戏开发、Web开发、嵌入式设备控制等领域。
Lua脚本实现可重入分布式锁
mlwsmqq的博客
01-09 1917
提到分布式锁，那一定绕不开Redisson，在深入Redisson源码时发现它使用了大量的lua脚本，为什么要使用lua脚本呢？答案就是它能够保证Redis操作的原子性；受到Redisson的启发，本文将带领大家一步步的通过lua脚本实现可重入分布式锁，还有两篇关于分布式锁的博客供大家参考。
Jedis 锁机制的实现
Qcsdn123的博客
06-29 722
Jedis 锁机制的实现
基于 Redis + Lua 脚本实现分布式锁，确保操作的原子性
askuld的博客
10-26 1155
2）lua字符串方式。
LUA批量原子性操作redis
qq_36042938的博客
04-23 1228
LUA命令： eval、evalsha
redis使用lua脚本来实现分布式锁
w的博客
07-06 451
redis分布式锁
Redis与Lua脚本（进阶篇）
爱晴禹
08-17 2191
Lua语言是在1993年由巴西一个大学研究小组发明，其设计目标是作为嵌入式程序移植到其他应用程序，它是由C语言实现的，虽然简单小巧但是功能强大，所以许多应用都选用它作为脚本语言，尤其是在游戏领域，暴雪公司的“魔兽世界”，“愤怒的小鸟”，Nginx将Lua语言作为扩展。Redis将Lua作为脚本语言可帮助开发者定制自己的Redis命令。Redis 2.6 版本通过内嵌支持 Lua 环境。也就是说一般的运用，是不需要单独安装Lua的。1、减少网络开销，在Lua脚本中可以把多个命令放在同一个脚本中运行；
lua多线程解决方案
Gnorth的专栏
10-15 7416
先讲下坑点： 1、lua_newthread 名称存在误导性，它只是拷贝一个栈，并不是创建一个线程。 2、不同的线程使用lua_newthread 出来的栈去调用lua代码，也要加锁，否则也会异常。 3、在lua底层有两个宏：lua_lock与lua_unlock，默认的情况下，这两个东西不起作用，lua的作者的本意是希望我们在有并发需求的时候，重写这两个宏，所以只要是底层用到这两个宏的地...
java redis分布式锁lua脚本代码实例
最新发布
03-02
Java Redis分布式锁是一种常用的实现方式，可以通过Redis的原子操作来实现分布式锁的功能。下面是一个Java Redis分布式锁的代码示例： ```java import redis.clients.jedis.Jedis; public class ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值