iava redis工具类

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量135 收藏
点赞数
分类专栏： 工具 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40331861/article/details/107492034
版权

redis工具类

package com.customerNoPlatform.configs;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import lombok.extern.slf4j.Slf4j;

import javax.annotation.Resource;

@Component
@Slf4j
public class RedisUtil {
	//锁名称
    public static final String LOCK_PREFIX = "redis_lock";
    //加锁失效时间，毫秒
    public static final int LOCK_EXPIRE = 300; // ms
    
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //=============================common============================  

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

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
    	long time=redisTemplate.getExpire(key, TimeUnit.SECONDS);
        log.info("根据key获取redis缓存失效时间，key:{},time:{}",key,time);
        return time;
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
        	boolean flag=redisTemplate.hasKey(key);
        	log.info("判断redis是否包含key，key:{},return:{}",key,flag);
            return flag;
        } 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) {
                boolean flag=redisTemplate.delete(key[0]);
                log.info("从redis删除key，key:{},return:{}",key,flag);
            } else {
                long count=redisTemplate.delete(CollectionUtils.arrayToList(key));
                log.info("从redis删除key，key:{},return:{}",key,count);
            }
        }
    }

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

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
    	if(key==null) {
    		log.info("从redis获取key，key:{},return:{}",key,null);
    		return null;
    	}else {
    		Object object=redisTemplate.opsForValue().get(key);
    		log.info("从redis获取key，key:{},return:{}",key,object);
    		return object;
    	}
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            log.info("保存键值到redis成功，key:{},value:{}",key,value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.info("保存键值到redis失败，key:{},value:{}",key,value);
            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);
                log.info("保存键值到redis成功并设定失效时间，key:{},value:{},time:{},",key,value,time);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    //================================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);
    }


    //============================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;
        }
    }
    
    /**
     *  分布式锁
     *
     * @param key key值
     * @return 是否获取到
     */
    @SuppressWarnings("unchecked")
	public boolean lock(String key){
        String lock = LOCK_PREFIX + key;
        return (Boolean) redisTemplate.execute((RedisCallback) connection -> {
  
            long expireAt = System.currentTimeMillis() + LOCK_EXPIRE + 1;
            Boolean acquire = connection.setNX(lock.getBytes(), String.valueOf(expireAt).getBytes());
  
  
            if (acquire) {
                return true;
            } else {
  
                byte[] value = connection.get(lock.getBytes());
  
                if (Objects.nonNull(value) && value.length > 0) {
  
                    long expireTime = Long.parseLong(new String(value));
                     // 如果锁已经过期
                    if (expireTime < System.currentTimeMillis()) {
                        // 重新加锁，防止死锁
                        byte[] oldValue = connection.getSet(lock.getBytes(), String.valueOf(System.currentTimeMillis() + LOCK_EXPIRE + 1).getBytes());
                        return Long.parseLong(new String(oldValue)) < System.currentTimeMillis();
                    }
                }
            }
            return false;
        });
    }
  
    /**
     * 删除锁
     *
     * @param key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }
}

 

日新不已
关注
专栏目录
java redis自增操作_利用spring-data-redis实现incr自增的操作
weixin_28939623的博客
02-13 2743
应该有不少人在使用spring-data-redis时遇到各种各样的问题。反正我是遇到了。由于是隔了一段时间才写的本篇博客，也懒得去重现哪些错误场景了，下面凭着记忆写了几个我遇到的问题：redis.clients.jedis.exceptions.JedisDataException: ERR value is not an integer or out of range使用的RedisTempl...
Redis
weixin_44960905的博客
07-14 1108
90年代基本的访问量都不太大，单个数据库完全够用，而且更多使用的是静态网页，服务器没有过多的压力。可能面临的问题发展过程：优化数据结构和索引–>文件缓存(IO)–>MemcachedMyISAM：表锁 十分影响效率，高并发会有问题Innodb：行锁之后使用分库分表来解决写的压力为什么要用NoSQL？用户的个人信息，社交网络，地理位置，用户自己产生的数据，用户日志等爆发式增长，这时就需要使用NoSQL数据库。什么是NoSQL？Not Only Sql 泛指非关系型数据库关系型数据库：表格，行和列用户的个人信
Redis学习笔记（基础）
weixin_74155781的博客
05-02 1064
Redis基础篇学习笔记
（五） spring boot 配置使用 redis
GEEK-BANANA
11-26 433
实际的项目中难免会使用到缓存来提高我们程序的运行效率，用的最多的也还是redis，所以我此篇文章主要来写我们在springboot项目中如何整合redis与使用redis 对于redis的使用其实很简单，也是数据库的一种，增删改查，没有什么太大的区别，只不过它的速度很快，因为redis使用的是内存进行查询 redis 中所包含的数据类型 ...
Redis缓存过期导致 cannot be cast to java.lang.String ""
qq_40929531的博客
01-09 4447
说明：这里我使用的远程连接工具为Redis Desktop Manager进行的调试 最近接收了一个项目，总是在运行一天后出现异常，之后通过服务器控制台发现报错cannot be cast to java.lang.String "" ,经过调试发现这是Redis 缓存过期导致的异常，为了解决问题我尝试从数据库中重新获取并存入Redis代码如下所示： public String ge...
redis基础学习笔记
weixin_43977307的博客
09-29 1430
1. 单机MySQL的年代90年代，一个基本的网站访问量一般不会太大，单个数据库完全足够!那个时候，更多的去使用静态网页 Html~服务器根本没有太大的压力!思考一下，这种情况下 : 整个网站的瓶颈是什么?数据量如果太大，一个机器放不下数据的索引（B+ Tree），一个机器内存也放不下访问量（读写混合），一个服务器承受不住2. Mencached（缓存）+MySQL+垂直拆分（读写分离）站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦!
已解决java.util.concurrent.CancellationException: 取消异常的正确解决方法，亲测有效！！！
小明的Java问道之路
04-25 1261
已解决java.util.concurrent.CancellationException: 取消异常的正确解决方法，亲测有效！！！
Redis场景总结
weixin_62773644的博客
03-08 2395
redis的场景总结
Java面试题
兴浩的博客
08-29 1643
1Java基础 1.1什么是Java虚拟机 Java 虚拟机是一个可以执行 Java 字节码的虚拟机进程。Java 源文件被编译成能被 Java 虚拟机执行的字节码文件。 1.2JDK 和 JRE 有什么区别？
iava.zip_iava类
09-23
在"iava.zip_iava类"这个主题中，我们将深入探讨接口的使用和实现。 首先，接口提供了类型之间的关联，让类可以实现多个接口，从而具有多种行为。这在设计大型系统时特别有用，因为它们可以帮助我们创建松散耦合的...
JavaClassViewer：使用iava反射查看类文件的所有详细信息
02-15
Java类文件查看器/反射器 Java程序使用反射来查看类文件的详细信息。 它与jdk中的javap命令有点类似，但显示了更多有组织的细节。 安装 从下面的zip下载并解压缩代码/类文件。 用法 代码 将类目录yourDirectory/...
Redis 哈希表 VS Java HaspMap , 哪家强？
m0_69305074的博客
06-14 459
Redis的字典本质上来说也是数组+链表的数据结构，这与Java中HashMap的数据结构很类似啦。
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1370
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 861
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 249
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 407
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 407
Java复习24（PTA)：多种排序的book类*
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 282
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
iava模拟简单计算器
10-13
在Java中，我们可以模拟一个简单计算器，通常通过设计一个`Calculator`类，包含加法、减法、乘法和除法等基本运算的方法。以下是简单的实现： ```java public class SimpleCalculator { // 加法方法 public int add(int num1, int num2) { return num1 + num2; } // 减法方法 public int subtract(int num1, int num2) { return num1 - num2; } // 乘法方法 public int multiply(int num1, int num2) { return num1 * num2; } // 除法方法（需要处理除数为零的情况） public int divide(int num1, int num2) throws ArithmeticException { if (num2 != 0) { return num1 / num2; } else { throw new ArithmeticException("除数不能为零"); } } // 主程序入口，让用户输入操作数和运算符 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入第一个数字:"); int num1 = scanner.nextInt(); System.out.println("请输入运算符 (+, -, *, /):"); char operator = scanner.next().charAt(0); System.out.println("请输入第二个数字:"); SimpleCalculator calculator = new SimpleCalculator(); switch (operator) { case '+': System.out.println("结果: " + calculator.add(num1, scanner.nextInt())); break; case '-': System.out.println("结果: " + calculator.subtract(num1, scanner.nextInt())); break; case '*': System.out.println("结果: " + calculator.multiply(num1, scanner.nextInt())); break; case '/': try { System.out.println("结果: " + calculator.divide(num1, scanner.nextInt())); } catch (ArithmeticException e) { System.out.println(e.getMessage()); } break; default: System.out.println("无效的运算符"); break; } scanner.close(); } } ``` 这个示例中，用户可以输入两个数字和一个运算符来进行相应的计算。如果选择除法，还需要检查除数是否为零，防止`ArithmeticException`的发生。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值