首页 > 数据库 >Redis 工具类

Redis 工具类

时间:2023-08-16 21:01:31浏览次数:44  
标签:return String Redis param key 工具 public redisTemplate

package com.infinitus.opp.meeting.utils;


import com.alibaba.nacos.shaded.com.google.common.collect.Lists;

import lombok.extern.slf4j.Slf4j;

import org.springframework.dao.DataAccessException;

import org.springframework.data.redis.core.RedisOperations;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.SessionCallback;

import org.springframework.data.redis.core.script.DefaultRedisScript;

import org.springframework.stereotype.Component;

import org.springframework.util.CollectionUtils;


import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import java.util.*;

import java.util.concurrent.TimeUnit;


/**

* Description:redis操作工具类  两步操作加事务

*

* @author helen

* @since 2023年08月07日

*/

@Slf4j

@Component

public class RedisUtil {


   public static final String REDIS_UNLOCK_SCRIPT = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then return redis.call(\"del\",KEYS[1]) else return 0 end;";

   @Resource

   private RedisTemplate<String, Object> redisTemplate;


   private DefaultRedisScript<Long> script = null;


   /**

    * 实例创建之后进行初始化

    */

   @PostConstruct

   private void init() {

       script = new DefaultRedisScript<Long>(REDIS_UNLOCK_SCRIPT, Long.class);

   }


   /**

    * 指定缓存失效时间

    *

    * @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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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((Collection<String>) 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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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.execute(new SessionCallback<Boolean>() {

               @Override

               public Boolean execute(RedisOperations operations) throws DataAccessException {

                   operations.multi();

                   redisTemplate.opsForHash().putAll(key, map);

                   if (time > 0) {

                       expire(key, time);

                   }

                   // This will contain the results of all ops in the transaction

                   operations.exec();

                   return true;

               }

           });

           return false;

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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.execute(new SessionCallback<Boolean>() {

               @Override

               public Boolean execute(RedisOperations operations) throws DataAccessException {

                   operations.multi();

                   redisTemplate.opsForHash().put(key, item, value);

                   if (time > 0) {

                       expire(key, time);

                   }

                   // This will contain the results of all ops in the transaction

                   operations.exec();

                   return true;

               }

           });

           return false;

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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 long hincr(String key, String item, long by) {

       return redisTemplate.opsForHash().increment(key, item, by);

   }


   /**

    * 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, long 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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           return 0;

       }

   }


   /**

    * 将set数据放入缓存

    *

    * @param key    键

    * @param time   时间(秒)

    * @param values 值 可以是多个

    * @return 成功个数

    */

   public long sSetAndTime(String key, long time, Object... values) {

       try {

           redisTemplate.execute(new SessionCallback<Long>() {

               @Override

               public Long execute(RedisOperations operations) throws DataAccessException {

                   operations.multi();

                   Long count = redisTemplate.opsForSet().add(key, values);

                   if (time > 0) {

                       expire(key, time);

                   }

                   // This will contain the results of all ops in the transaction

                   operations.exec();

                   return count;

               }

           });

           return 0;

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           return 0;

       }

   }


   /**

    * 获取set缓存的长度

    *

    * @param key 键

    * @return

    */

   public long sGetSetSize(String key) {

       try {

           return redisTemplate.opsForSet().size(key);

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           return 0;

       }

   }


   /**

    * 移除值为value的

    *

    * @param key    键

    * @param values 值 可以是多个

    * @return 移除的个数

    */

   public long setRemove(String key, Object... values) {

       try {

           return redisTemplate.opsForSet().remove(key, values);

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           return null;

       }

   }


   /**

    * 获取list缓存的长度

    *

    * @param key 键

    * @return

    */

   public long lGetListSize(String key) {

       try {

           return redisTemplate.opsForList().size(key);

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           return false;

       }

   }


   /**

    * 将list放入缓存

    *

    * @param key   键

    * @param value 值

    * @param time  时间(秒)

    * @return

    */

   public boolean lSet(String key, Object value, long time) {

       try {

           redisTemplate.execute(new SessionCallback<Boolean>() {

               @Override

               public Boolean execute(RedisOperations operations) throws DataAccessException {

                   operations.multi();

                   redisTemplate.opsForList().rightPush(key, value);

                   if (time > 0) {

                       expire(key, time);

                   }

                   // This will contain the results of all ops in the transaction

                   operations.exec();

                   return true;

               }

           });

           return false;

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           return false;

       }

   }


   /**

    * 将list放入缓存

    *

    * @param key   键

    * @param value 值

    * @param time  时间(秒)

    * @return

    */

   public boolean lSet(String key, List<Object> value, long time) {

       try {

           redisTemplate.execute(new SessionCallback<Boolean>() {

               @Override

               public Boolean execute(RedisOperations operations) throws DataAccessException {

                   operations.multi();

                   redisTemplate.opsForList().rightPushAll(key, value);

                   if (time > 0) {

                       expire(key, time);

                   }

                   // This will contain the results of all ops in the transaction

                   operations.exec();

                   return true;

               }

           });

           return false;

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           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) {

           log.error(e.getMessage(), e);

           return false;

       }

   }


   /**

    * 移除N个值为value

    *

    * @param key   键

    * @param count 移除多少个

    * @param value 值

    * @return 移除的个数

    */

   public long lRemove(String key, long count, Object value) {

       try {

           return redisTemplate.opsForList().remove(key, count, value);

       } catch (Exception e) {

           log.error(e.getMessage(), e);

           return 0;

       }

   }


   //===============================lock=================================


   /**

    * redis加锁,适合redis单机锁,集群版请用redlock算法,没有加入锁续期。

    *

    * @param key           键

    * @param valExpireTime 值的过期时间

    * @param valTimeUnit   值的过期时间的时间单位

    * @param tryTimeOut    尝试加锁的过期时间,单位(毫秒)

    * @return 唯一id, 释放锁时候根据唯一Id进行释放,避免删除其他线程的锁

    */

   public String lock(String key, Long valExpireTime, TimeUnit valTimeUnit, Long tryTimeOut) throws Exception {

       long nowTime = System.currentTimeMillis();

       long expireTime = nowTime + tryTimeOut;

       // 对没给线程分配不同的随机数val,防止在释放锁时,释放其他线程的锁

       String randomVal = UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();

       while (nowTime <= expireTime) {

           // 加锁,原子操作

           Boolean lockSuccess = redisTemplate.opsForValue().setIfAbsent(key, randomVal, valExpireTime, valTimeUnit);

           if (lockSuccess) {

               return randomVal;

           } else {

               // 进入到下一次循环判断,加入时间gap,在高度竞争的环境下减少cpu的占用

               Thread.sleep(100);

           }

           nowTime = System.currentTimeMillis();

       }

       return null;

   }


   /**

    * redis释放锁,适合redis单机锁,集群版请用redlock算法

    *

    * @param key 键

    * @param val 值,即加锁返回的唯一id

    * @return 是否释放锁成功,失败有可能是该锁已经过期被其他线程占有,也有可能锁已超时被redis删除。

    */

   public boolean unlock(String key, String val) {

       Long executeResult = redisTemplate.execute(script, Lists.newArrayList(key), val);

       if (null != executeResult && executeResult.longValue() == 1L) {

           return true;

       } else {

           return false;

       }

   }


   /**

    * redis模糊查找key

    *

    * @param pattern

    * @return

    */

   public Set<String> keys(String pattern) {

       return redisTemplate.keys(pattern);

   }


   /**

    * zset-根据value值增加对应的score

    * @param key

    * @param value

    * @param score

    * @return

    */

   public Double zIncrementScore(String key, Object value, double score) {

       return redisTemplate.opsForZSet().incrementScore(key, value, score);

   }

   /**

    * zset-根据value值获得对应的score

    * @param key

    * @param value

    * @return

    */

   public Double zScore(String key, Object value) {

       return redisTemplate.opsForZSet().score(key, value);

   }


   /**

    * zset-add

    * @param key

    * @return

    */

   public Boolean zAdd(String key, Integer id,double score) {

       return redisTemplate.opsForZSet().add(key,id, score);

   }


   /**

    * zset-add

    * @param key

    * @return

    */

   public Boolean zAdd(String key, Object id,double score) {

       return redisTemplate.opsForZSet().add(key,id, score);

   }


   /**

    * zset-移除对应值

    * @param key

    * @param value

    * @return

    */

   public Long zRemove(String key, Object value) {

       return redisTemplate.opsForZSet().remove(key, value);

   }

   /**

    * zset-获得指定范围元素--分数从高到低--不含分值

    * @param key

    * @param offset

    * @param count

    * @return

    */

   public Set<Object> zReverseRange(String key, long offset,long count) {

       return redisTemplate.opsForZSet().reverseRange(key, offset, count);

   }

   /**

    * 获取排位

    * @param key

    * @param o

    * @return

    */

   public Long reverseRank(String key,Object o) {

       return redisTemplate.opsForZSet().reverseRank(key,o);

   }

   /**

    * 根据排位获取数据

    * @param key

    * @param start

    * @param end

    * @return

    */

   public Set<Object>  reverseRange(String key,long start, long end) {

       return redisTemplate.opsForZSet().reverseRange(key,start,end);

   }


}

标签:return,String,Redis,param,key,工具,public,redisTemplate
From: https://blog.51cto.com/u_7218743/7113444

相关文章

  • JVM调优(十七)JVM常见调优问题和工具的使用
    JVM调优(十七)JVM常见调优问题和工具的使用说辞熟悉GC常见算法熟悉常见的垃圾回收器,具有实际JVM调优经验1什么是调优根据需求进行JVM优化和预调优优化JVM的运行环境(慢、卡顿)解决JVM运行过程中出现的各种问题(OOM)2JVM常用调优命令jps:JDK自带,全称javaprocess,列出系......
  • Golang之数据库转换结构体工具table2struct
    另外一个根据json生成对应结构体在线工具: https://mholt.github.io/json-to-go/ 安装:gogetgithub.com/gohouse/converter或者下载对应平台的二进制文件https://github.com/gohouse/converter/releases 引入该包进行转换的使用方式可以参考github上的使用示例,为......
  • Redis入门
    1.认识NoSQL1.1 什么是NoSQLNoSQL最常见的解释是"non-relational",很多人也说它是"NotOnlySQL"NoSQL仅仅是一个概念,泛指非关系型的数据库区别于关系数据库,它们不保证关系数据的ACID特性NoSQL是一项全新的数据库革命性运动,提倡运用非关系型的数据存储,相对于铺天盖地的关系......
  • 一个可将执行文件打包成Windows服务的.Net开源工具
    Windows服务一种在后台持续运行的程序,它可以在系统启动时自动启动,并在后台执行特定的任务,例如监视文件系统、管理硬件设备、执行定时任务等。今天推荐一个可将执行文件打包成Windows服务的工具,方便我们封装第三个的软件。项目简介winsw一个基于.Net开发的开源项目,可以帮助开发......
  • 免费-几款面向敏捷研发团队的敏捷项目管理工具
    在当今快节奏的商业环境中,许多企业纷纷开始转型Scrum敏捷开发。然而,要实现敏捷开发并确保项目的成功,不但要系统的学习敏捷,而且也需要好的敏捷工具来提高效率和促进团队协作。本文将介绍一些常用的敏捷项目开发工具,帮助您更好地管理和推动项目的进展。Leangoo领歌Leangoo领歌是Scrum......
  • 使用hutool封装的Excel工具类
    好用的工具类hutool工具类hutool操作excel这篇文章使用hutool的excel包封装项目中使用的excel工具类;引入包可以简单直接引入hutool-all,但是如果不用其他的话建议单独引入excel包<dependency><groupId>cn.hutool</groupId><artifactId>hutool-......
  • IOS设备管理工具ITOOLS介绍
    目前市场上的IOS系列的管理工具不少,从嫡系itune,cydia,到91助手,同步推等。总体上我更推荐iToolsiTools的目标简单而清晰—-做最好的苹果设备管理软件。iTools——创想天空(thinksky,深圳的公司,核心人员是从腾讯出来的,难怪做产品有一套)第一个核心产品,是一款简洁有着“无需越狱,即可同步”......
  • Jira 项目管理工具
    Jira仅用于学习,商业化推荐购买正版目录JiraJira平台应用市场前期准备:安装-1,安装Mysql-2,安装jira-3,配置mysql-connector-java-4,配置Agent.jar-5,修改setenv.sh-6,启动应用-生成License以下命令我放在了/opt/atlassian/jira目录-7,完成其它Jira平台应用市场可......
  • 2023-08-16 flutter之执行命令【flutter doctor】报错:Android sdkmanager tool not fo
    步骤如下: 注:请确保你有足够的空间安装并运行as工具。 ......
  • PPT| 某集团公司数字化转型咨询框架工具培训材料 P52
    PPT共52页,由于篇幅有限,以下为部分资料.......