java加redis锁

已于 2022-12-06 15:26:06 修改
阅读量2.8k 收藏 8
点赞数 2
分类专栏： redis锁 文章标签： redis java
于 2022-12-06 15:12:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45110541/article/details/128203205
版权

redis锁的作用：

防止接口重复提交数据

maven包：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.10.1</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <!-- for Spring Data Redis v.2.1.x -->
    <artifactId>redisson-spring-data-21</artifactId>
    <version>3.10.1</version>
</dependency>
<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

代码示例：

controller层

@PostMapping("/redis")
public JsonResult importFile(@RequestBody FileForm fileForm) {
    //定义一个键
    String lockKey = "REDIS_INSERT";
    if (redisUtil.tryLock(lockKey, 10, 60, TimeUnit.SECONDS)) {
        try {
            //调用自己业务层方法
        } catch (BizException e) {
            e.printStackTrace();
            return JsonResult.error(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return JsonResult.error("接口bug返回的提示信息");
        }finally {
            redisUtil.unlock(lockKey);
        }
    } else {
        return JsonResult.error("请稍后再试");
    }
}

RedisUtil工具类：

package com.caac.common.utils;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis 工具类
 */
@Component
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key 键
     * @param delta  要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 根据key模糊查询
     * @param key
     * @return
     */
    public Set<String> keys(String key){
        return redisTemplate.keys("*" + key + "*");
    }

    /**
     * 获取锁
     *
     * @param lockKey 锁实例key
     * @return 锁信息
     */
    public RLock getRLock(String lockKey)
    {
        return redissonClient.getLock(lockKey);
    }

    /**
     * 加锁
     *
     * @param lockKey 锁实例key
     * @return 锁信息
     */
    public RLock lock(String lockKey)
    {
        RLock lock = getRLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * 加锁
     *
     * @param lockKey 锁实例key
     * @param leaseTime 上锁后自动释放锁时间
     * @return true=成功；false=失败
     */
    public Boolean tryLock(String lockKey, long leaseTime)
    {
        return tryLock(lockKey, 0, leaseTime, TimeUnit.SECONDS);
    }

    /**
     * 加锁
     *
     * @param lockKey 锁实例key
     * @param leaseTime 上锁后自动释放锁时间
     * @param unit 时间颗粒度
     * @return true=加锁成功；false=加锁失败
     */
    public Boolean tryLock(String lockKey, long leaseTime, TimeUnit unit)
    {
        return tryLock(lockKey, 0, leaseTime, unit);
    }

    /**
     * 加锁
     *
     * @param lockKey 锁实例key
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @param unit 时间颗粒度
     * @return true=加锁成功；false=加锁失败
     */
    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
    {
        RLock rLock = getRLock(lockKey);
        boolean tryLock = false;
        try
        {
            tryLock = rLock.tryLock(waitTime, leaseTime, unit);
        }
        catch (InterruptedException e)
        {
            return false;
        }
        return tryLock;
    }

    /**
     * 释放锁
     *
     * @param lockKey 锁实例key
     */
    public void unlock(String lockKey)
    {
        RLock lock = getRLock(lockKey);
        lock.unlock();
    }

    /**
     * 释放锁
     *
     * @param lock 锁信息
     */
    public void unlock(RLock lock)
    {
        lock.unlock();
    }
}

总结：

1.导包

2.copy工具类

3.在自己想要加锁的方法上调用工具类加锁的方法

4.记得释放锁

是不是嘎嘎简单

陳陳chen.
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
redis utils 工具类
07-08
java 集成redis 工具类
封装RedisTemplate的RedisUtil工具类
choufei4244的博客
07-05 1250
public class RedisUtil { private RedisTemplate<String, Object> redisTemplate; public void setRedisTemplate(RedisTemplate<Strin...
基于Redis实现分布式锁——Java版本
最新发布
qq_41523340的博客
05-09 543
设定业务超时时间，到期自动解锁。当超时时间小于执行业务时间时，其他线程会拿到锁，而之前的线程执行完后又会解锁，变得混乱，导致线程安全问题。解锁时判断锁是否和自己假的锁标识一样，标识使用UUID+线程ID，标识一样才释放锁。某个线程先判断锁是自己的，此时由于其他原因阻塞，比如Full GC，其他线程拿到锁，之前的线程再解锁，但是解的并不是自己的锁，导致线程安全问题。去中心化，不要主从，每个节点都需要获取锁，使用了红锁算法。3、超时时间不好设置，有可能超时自动释放，虽然不会有误删，但是存在其他线程重新加锁。
RedisUtils工具类
五道口
07-10 9681
Java版的Redis工具类，提供了增删改查Hash等工具方法。方法都经过验证，直接使用。并拓展了批量写入等方法，高效、简洁、优雅。
Redis分布式锁注解（Java实现）
weixin_47224121的博客
06-07 1848
在项目中遇到了插入重复数据的问题，为了防止并发造成重复数据的插入，故使用加锁，而传统的加锁是单机锁并不适用分布式项目，故采用Redis分布式锁。
java 锁
JackLi31742的博客
09-24 331
Lock、synchronized和ReadWriteLock的区别和联系 http://blog.csdn.net/qq_20641565/article/details/53208909Java中的ReentrantLock和synchronized两种锁定机制的对比 http://blog.csdn.net/fw0124/article/details/6672522java volita
java的锁
乐百寿
03-03 90
java的各种锁： 一，悲观锁，乐观锁   悲观锁：认为自己在使用数据的时候一定有别的线程来修改数据.在获取数据的时候会先加，出观锁 锁，确保数据不公被别的线程修改锁实现：关键字svnchronized、接口Lock的实现类适用场乐:写操作我多.先加锁可以保证写操作时数据正确。   乐观锁：认为自在使用数据时不公仃别的线程修改数据.所以不公添加锁.只是在更新数据的时候去判断之前有没有别的线程更新了这个数据锁实现：CAS算法,例如Atomiclnteger类的原子自增是同过CAS自旋实现适用场景：读操作较多
java中redis锁的封装
05-04
内容：封装好的redis锁 使用场景： 1.并发情况下 2.对某个字段状态的处理 3.支付回调，重复收到回调数据 使用方法： Object result = redisLockTemplate.execute("REDIS:LOCK:" + id, 1, TimeUnit.SECONDS, new ...
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
redis实现分布式锁(java/jedis)
08-06
redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现 redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现
java操作redis.docx
04-18
Java 操作 Redis Java 操作 Redis 是使用 Java 语言来访问和操作 Redis 数据库的方法。Redis 是一个高性能的 NoSQL 数据库，使用 Java 语言来操作它可以提高开发效率和性能。本文档将详细介绍使用 Java 操作 Redis...
RedisTest
Leon_Jinhai_Sun的博客
09-10 370
@Test public void test44() { Map<String, Object> map = new HashMap<String, Object>(); // map.put("powerConsumption", 80); // map.put("reportStatus", 2); // ...
Redis工具类
Jin的随手笔记
03-28 3215
​ 直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注解注入。
Java三种方式实现redis分布式锁
热门推荐
了迹奇有没
04-28 1万+
一、引入原因 在分布式服务中，常常有如定时任务、库存更新这样的场景。 在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。 在库存更新这样的场景中，我们服务对数据库同一条记录进行更新，并记录。对记录更新可以使用分布式锁，但对操作进行记录时，可能造成读未提交，造成记录错乱的情况。 在以上的场景中，我们引入了分布式事务锁。 二、分布式锁实现过程中的问题 问题一：异常导致锁没有释放 这个问题形成的原因就是程序
【Java】三种方案实现 Redis 分布式锁
人生苦短，我用python
11-04 5721
三种 Redis 分布式锁的实现方案
Redis学习（八）Java三种方式实现分布式锁
ACGkaka的博客
08-14 4627
Redis学习（八）Java三种方式实现分布式锁
深入学习 Redis - 分布式锁底层实现原理，以及实际应用
CYK_byte的博客
09-20 5267
lua 语言特别轻量（实现一个 lua 解释器，消耗的体积非常小），可以使用 lua 编写一些逻辑，把这个脚本上传到 redis 服务器上，然后就可以让客户端来控制 redis 执行上述脚本了.最重要的一点就是，redis 执行一个 lua 脚本，就相当于在 redis 上执行一个命令一样，是原子的. 并且 redis 官方文档中也明确说，lua 就属于是 事务 的替代方案.例如前面的 “买票” 案例.elsereturn 0end;
java中redis加写锁
03-28
在Java中使用Redis加写锁可以通过以下步骤： 1. 首先，需要创建一个Redis连接，可以使用Jedis或Lettuce等Redis客户端库来建立连接。 2. 接下来，使用Redis的setnx命令设置一个锁键。setnx命令会在锁键不存在时设置锁键的值为1，并返回1表示设置成功；如果锁键已经存在，则返回0表示设置失败。 3. 在获取到锁之后，可以执行需要加锁的操作。在操作完成之后，需要释放锁。释放锁可以使用Redis的del命令，将锁键删除即可。 以下是一个简单的Java代码示例，演示如何使用Redis加写锁： ```java import redis.clients.jedis.Jedis; public class RedisLock { private Jedis jedis; public RedisLock(String host, int port) { this.jedis = new Jedis(host, port); } public boolean acquireLock(String lockKey) { // 使用setnx命令设置锁键 long result = jedis.setnx(lockKey, "1"); if (result == 1) { // 获取锁成功 return true; } else { // 获取锁失败 return false; } } public void releaseLock(String lockKey) { // 使用del命令释放锁 jedis.del(lockKey); } public static void main(String[] args) { RedisLock redisLock = new RedisLock("localhost", 6379); String lockKey = "mylock"; // 获取锁 boolean acquiredLock = redisLock.acquireLock(lockKey); if (acquiredLock) { try { // 执行需要加锁的操作 System.out.println("执行需要加锁的操作..."); } finally { // 释放锁 redisLock.releaseLock(lockKey); } } else { System.out.println("获取锁失败，无法执行操作。"); } } } ``` 注意，以上代码仅仅是一个简单的示例，实际应用中可能需要更加健壮的锁实现，例如考虑锁超时、锁重入等情况。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值