java Redis 工具类（最全面使用）基于Sprintboot

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量482 收藏 2
点赞数 1
分类专栏： springboot 文章标签： java redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BuildH/article/details/128327581
版权

Redis 工具类 基于Springboot

加锁工具类

package cn.com.bilibili.alter.manager.tools;

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RFuture;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class RedissonLockSupport {

    private List<String> lockKeys = new ArrayList<>();

    @Resource
    RedisTemplate redisTemplate;

    @Resource
    RedissonClient redissonClient;

    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            boolean locked = lock.tryLock(waitTime, leaseTime, unit);
            if (locked) lockKeys.add(lockKey);
            return locked;
        } catch (InterruptedException | CancellationException e) {
            log.error("尝试获取锁 {} 失败", lockKey);
        }
        return Boolean.FALSE;
    }

    public void removeAndSaveList(String key, List list, long expire, TimeUnit timeUnit) {
        redisTemplate.delete(key);
            redisTemplate.opsForList().leftPushAll(key,list);
        redisTemplate.expire(key, expire, timeUnit);
    }

    public List getList(String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    public boolean unLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                lock.unlock();
                return lockKeys.remove(lockKey);
            }
        } catch (Exception e) {
            log.error("解锁 {} 失败", lockKey);
        }
        return false;
    }

    public Boolean tryLockAsync(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            RFuture<Boolean> locked = lock.tryLockAsync(waitTime, leaseTime, unit);
            if (locked.get()) lockKeys.add(lockKey);
            return locked.get();
        } catch (InterruptedException | ExecutionException e) {
            log.error("尝试获取Async锁 {} 失败", lockKey);
        }
        return Boolean.FALSE;
    }

    public boolean unAsyncLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                RFuture<Void> future = lock.unlockAsync();
                if (future.await(5 * 1000) && future.isSuccess()) {
                    return lockKeys.remove(lockKey);
                }
            }
        } catch (Exception e) {
            log.error("解Async锁 {} 失败", lockKey);
        }
        return false;
    }

    public boolean isHoldLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                return true;
            }
        } catch (Exception e) {
            log.error("查询锁状态失败", lockKey);
        }
        return false;
    }

}

缓存工具类

package cn.com.bilibili.alter.manager.tools;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * @Author buildH
 * @Date 2022/11/10 10:37
 */
@Slf4j
@Component
public class RedisUtil {
//    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    RedisTemplate redisTemplate;

//    public RedisUtil(RedisTemplate<String, Object> rt ) {
//        this. redisTemplate = rt;
//    }
//    public RedisUtil(RedisTemplate<String, Object> rt ) {
//        this. redisTemplate = rt;
//    }

    /**
     * 指定缓存失效时间
     * @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
     */
    public void del(String key) {
        if (key != null) {
            redisTemplate.delete(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 值
     * @param time 时间(秒)
     * @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 值
     * @param time 时间(秒)
     * @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;
        }
    }
}

配置文件

spring:
  redis:
    timeout: 6000ms
    password:
    cluster:
      max-redirects: 5  # 获取失败 最大重定向次数
      nodes:             #放 redis 节点
        - 172.23.47.1:7479
        - 172.23.47.2:7481
        - 172.23.47.3:7480
        - 172.23.47.4:7480
        - 172.23.47.5:7482
        - 172.23.47.6:7481
    lettuce:
      pool:
        max-active: 1000  #连接池最大连接数（使用负值表示没有限制）
        max-idle: 10 # 连接池中的最大空闲连接
        min-idle: 5 # 连接池中的最小空闲连接
        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）

加锁工具类的使用

private Semaphore semaphore = new Semaphore(3);
boolean isHoldLock = false;
boolean hasPermit = false;
try{
// 配置锁的超时时间  锁的名字，锁的名字也就是key根据自己的来，需要唯一的
    isHoldLock = redissonLockSupport.tryLock(LockType.FLINK_VERSION_MANAGEMENT.name(), 1000, 20 * 60 * 1000, TimeUnit.MILLISECONDS);
    if (isHoldLock) {
        hasPermit = semaphore.tryAcquire();
        if (hasPermit) {
            //写自己的逻辑  调用自己需要调用的方法
            addJobTags();
            tagsJob();
            calculateTagsProportion();
        } else {
            log.error("too many batch metric statistic task not finish, skip current task....");
        }
    }
}catch (Exception e ){
    log.error("error to compute traffic result...");
}finally {
    if (hasPermit) {
        semaphore.release();
    }
    if (isHoldLock) {
        redissonLockSupport.unLock(LockType.KAFKA_TRAFFIC_BATCH_STATISTIC_JOB.name());
    }
}
BuildH
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis utils 工具类
07-08
java 集成redis 工具类
Redis-redisson工具类使用和常用的锁功能
瑶山的博客
04-21 4783
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。 pom引入 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <versi
分布式锁Redisson实战（一）RedisUtils工具类和maven坐标
qq_34412985的博客
01-30 3575
package com.*.data.busisystem; import org.redisson.Config; import org.redisson.Redisson; import org.redisson.RedissonClient; import org.redisson.SingleServerConfig; import org.redisson.core.RAtomicLong; import org.redisson.core.RBucket; import org.redisso
java Redis工具类 RedisUtils
qq_35004315的博客
03-01 442
【代码】java Redis工具类 RedisUtils。
redisson工具类_一文掌握 Redisson 分布式锁的原理（值得收藏）
weixin_32382335的博客
01-24 472
Redisson可以直接查看 Github Redisson官网 介绍, 没有了解过的小伙伴, 看一下 Redisson 的 WIKI 目录, 仔细瞅瞅 Redis 是如何被 Redisson 武装到牙齿的这里先过一下和文章有关的一部分内容通过项目简介可以看出来, 写这个项目介绍的人水平非常哇塞哈, 从第一段咱们就知道了两个问题Redisson 是什么Redisson 是架设在 Redis 基础上...
java操作Redis数据库的redis工具,RedisUtil,jedis工具JedisUtil,JedisPoolUtil
duhua的博客
07-27 5479
java操作Redis数据库的redis工具,RedisUtil,jedis工具JedisUtil,JedisPoolUtil,自己抽空写的,基本只要理解什么是get,什么是set就可以使用Redis数据库了
java使用redis
csdnzhang365的博客
11-18 1067
如果键不存在，它将被视为一个空的哈希与此命令将返回0。同incr 类似，加指定值，key 不存在时候会设置 key，并认为原来的 value 是 0。第一次执行是成功的，但第二次执行相同的命令失败，原因是 field 已经存在了。如果 field 已经存在，返回 0， nx 是not exist 的意思。设置 hash field 为指定值，如果 key 不存在，则先创建。给指定key的字符串值追加value,返回新字符串值的长度。获取全部指定的 hash filed。取指定key的value值的长度。
ssm快速集成redis缓存
飞奔的波大爷的博客
05-31 1175
基于Spring SpringMVC Mybaits框架基础上。 安装好redis： Redis 安装（Windows和Linux ） https://blog.csdn.net/qq_22860341/article/details/77533372 1，引入依赖或者jar &amp;lt;!--redis--&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt...
Java中RedisUtils工具类的使用
ddwangbin520的博客
06-27 2331
本文将提供一个redis的工具类，可以用在Spring boot以及Spring Cloud项目中，本工具类主要整合了将Redis作为NoSql DB使用时的常用方法，以StringRedisTemplate实例为基础，封装了读取、写入、批量写入多个Redis hash等方法，降低了Redis学习成本，使业务代码更加高效、简洁、优雅。
Redis数据操作工具类--Java语言
Jerry545的博客
07-16 262
基于Java语言的Redis工具类
Spring使用Redisson工具类操作ZSet集合（基础操作汇总）
张小凡
03-19 2896
主要介绍Spring，如何使用Redisson工具类操作ZSet集合！
可能是方法最全Redis静态工具类（RedisUtils.java）
06-28
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！
redis工具类.txt
08-13
springboot和redis集成 简化redis语句的工具类
springboot统返回结果集工具类demo
03-15
springboot统返回结果集工具类demo
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
SpringBoot整合Redis源码 mybatis实战源码 封装RedisUtils工具类源码 redis缓存mybatis数据源码
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统 开发工具 想法2017.2 开发环境 JDK 玛文 MySQL的 弹簧靴 Redis 兔子MQ 1.8 3.2.2 5.7 1.5.10发布 3.2 4倍 项目启动说明 1，启动前，请配置application....
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 956
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 895
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 819
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
springboot 引入redis工具类
10-15
在使用SpringBoot引入Redis工具类时，首先需要在pom.xml文件中添加以下依赖： ```xml <!-- SpringBoot Data Redis --> <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值