redisUtils

最新推荐文章于 2024-07-08 15:22:13 发布
最新推荐文章于 2024-07-08 15:22:13 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011493599/article/details/52636545
版权 
package com.utils.redis;

import com.nonobank.app.log.LogUtils;
import comutils.SerializeUtil;
import comutils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.util.Pool;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * redis工具类
 *
 * @author liangjun
 */
@Component("redisUtil")
public class RedisUtil<T> {

    private final long DEFAULT_LOCK_TIMEOUNT = 10000l;
    @Autowired
    private Pool<Jedis> redisPool;

    public synchronized Jedis getJedis() {
        Jedis jedis = null;
        try {
            jedis = redisPool.getResource();
        } catch (Exception e) {
            LogUtils.error("redisPool resource", e);
        }
        return jedis;
    }

    public String set(String key, String value) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.set(key, value);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    /**
     * @param key
     * @param value
     * @param expireTime seconds(int)
     * @return
     */
    public String set(String key, String value, int expireTime) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.setex(key, expireTime, value);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public Long setnx(String key, String value) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.setnx(key, value);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public Long expire(String key, int seconds) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.expire(key, seconds);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public double incrByFloat(String key, double value) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.incrByFloat(key, value);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public String get(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.get(key);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public Long del(final String... keys) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.del(keys);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    public Long del(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis == null ? null : jedis.del(key);
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

    /************************************************************************* 新加的 ******************************************************************************/

    /**
     * 失效时间-秒
     *
     * @param key
     * @param map
     * @param expireTime
     */
    public boolean setMap(String key, Map<String, String> map, int expireTime) {
        Jedis jedis = getJedis();
        try {
            String result = jedis.hmset(key, map);
            if (StringUtils.isNotEmpty(result) && result.equalsIgnoreCase("OK")) {
                jedis.expire(key, expireTime);
                return true;
            } else {
                return false;
            }
        } finally {
            jedis.close();
        }
    }

    /**
     * 获得结果 set
     *
     * @param key
     */
    public String getMapKey(String key, String field) {
        Jedis jedis = getJedis();
        try {
            String result = jedis.hget(key, field);
            if (StringUtils.isNotEmpty(result) && result.equalsIgnoreCase("nil")) {
                return null;
            } else {
                return result;
            }
        } finally {
            jedis.close();
        }
    }

    /**
     * 获得结果 list
     *
     * @param key
     */
    public List<String> getMapVal(String key, String field) {
        Jedis jedis = getJedis();
        try {
            return jedis.hmget(key, field);
        } finally {
            jedis.close();
        }
    }

    /**
     * 获得结果 set
     *
     * @param key
     */
    public Set<String> getMapKeys(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.hkeys(key);
        } finally {
            jedis.close();
        }
    }

    /**
     * 获得结果 list
     *
     * @param key
     */
    public List<String> getMapVals(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.hvals(key);
        } finally {
            jedis.close();
        }
    }

    /**
     * 失效时间:一个小时
     *
     * @param key
     * @param list
     */
    public void setPushList(String key, List<String> list, int expireTime) {
        Jedis jedis = getJedis();
        try {
            for (String str : list) {
                jedis.lpush(key, str);
            }
            jedis.expire(key, expireTime);
        } finally {
            jedis.close();
        }
    }

    /**
     * 失效时间-秒
     *
     * @param key
     * @param arrays
     * @param expireTime
     */
    public long setArrayList(String key, String[] arrays, int expireTime) {
        Jedis jedis = getJedis();
        try {
            long rows = jedis.sadd(key, arrays);
            if (rows == 1 || rows == 0) {
                jedis.expire(key, expireTime);
            }
            return rows;
        } finally {
            jedis.close();
        }
    }

    /**
     * 获取整个列表值
     *
     * @param key
     */
    public List<String> getList(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.lrange(key, 0, -1);
        } finally {
            jedis.close();
        }
    }

    public List<Object> pipelined(Map<String, String> datas) {
        try (Jedis resource = getJedis();
             Pipeline pipelined = resource.pipelined();) {
            datas.forEach((k, v) -> {
                pipelined.set(k, v);
            });
            List<Object> objects = pipelined.syncAndReturnAll();
            return objects;
        } catch (Exception e) {
        }
        return null;

    }


    /**
     * 被存放的对象必须实现java.io.Serializable接口
     * @param key
     * @param obj
     * @return
     */
    /**
     * 被存放的对象必须实现java.io.Serializable接口
     *
     * @param key
     * @param obj
     * @return
     */
    public String setObject(String key, Object obj, int time) {
        if (key != null && obj != null) {
            Jedis jedis = getJedis();
            if (jedis == null) {
                return null;
            }
            //    		 String s = jedis.set(key.getBytes(),SerializeUtil.serialize(obj));
            String s = jedis.setex(key.getBytes(), time, SerializeUtil.serialize(obj));

            if (jedis != null)
                jedis.close();

            return s;
        }
        return "NO";
    }

    public String setObject(String key, Object obj) {
        if (key != null && obj != null) {
            Jedis jedis = getJedis();
            if (jedis == null) {
                return null;
            }
            String s = jedis.set(key.getBytes(), SerializeUtil.serialize(obj));
            if (jedis != null)
                jedis.close();

            return s;
        }
        return "NO";
    }

    public Object getObject(String key) {

        Jedis jedis = getJedis();
        try {
            if (jedis == null)
                return null;
            byte[] objFormRedis = jedis.get(key.getBytes());
            if (objFormRedis != null && objFormRedis.length > 0) {
                Object obj = SerializeUtil.unserialize(objFormRedis);
                return obj;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (jedis != null)
                jedis.close();
        }

        return null;
    }

    public void ConstantForRedis(String key) {
        Jedis jedis = getJedis();
        if (jedis != null) {
            jedis.del(key.getBytes());
        }

    }

    public void delObject(String key) {
        Jedis jedis = getJedis();
        try {
            jedis.del(key.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (jedis != null)
                jedis.close();
        }

    }

    public long increment(String key) {
        Jedis jedis = getJedis();
        long n = jedis.incr(key);
        if (jedis != null)
            jedis.close();
        return n;
    }

    /**
     * 存储 对象集合
     * @param key
     * @param objList
     * @return
     */
    public String setObjectList(String key, List<T> objList, int expireTime) {
        String status = "No";
        if (key != null && objList != null) {
            Jedis jedis = getJedis();
            if (jedis == null) {
                return null;
            }
            try {
                status = jedis.set(key.getBytes(), ObjectsTranscoder.serialize(objList));
                jedis.expire(key, expireTime);
                if (status != null && "OK".equalsIgnoreCase(status)) {
                    LogUtils.audit("将数据存入redis,key=" + key);
                } else {
                    LogUtils.error("将券码数据存入redis出错，s=" + status);
                }
            } catch (Exception e) {
                LogUtils.error("将券码数据存入redis出错，s=" + status);
            } finally {
                if (jedis != null)
                    jedis.close();
            }
        }

        return status;
    }

    /**
     * 根据key，获取对象集合
     * @param key
     * @return
     */
    public List<T> getObjectList(String key) {

        Jedis jedis = getJedis();
        try {
            if (jedis == null)
                return null;
            byte[] in = null;
            in = jedis.get(key.getBytes());
            if (in != null) {
                List<T> resList = null;
                resList = ObjectsTranscoder.deserialize(in);
                LogUtils.audit("redis查询对象集合成功");
                return resList;
            }
        } catch (Exception e) {
            LogUtils.error("redis查询出现异常，key=" + key + "," + e);
        } finally {
            if (jedis != null)
                jedis.close();
        }

        return null;
    }

    /**
     * 获取锁
     * @param lockKey
     * @param lockValue
     * @param mills  持有锁时间,单位毫秒
     * @return
     */
    public boolean lock(String lockKey,String lockValue,long mills){
        boolean result=false;
        try(Jedis resource = redisPool.getResource()){
            String set = resource.set(lockKey, lockValue, "NX", "PX", mills);
            result = "OK".equals(set);
        }catch (Exception e){
            LogUtils.error("--->>lock excption--->>key=" + lockKey, e);
        }
        LogUtils.audit("--->>lock result--->>key=" + lockKey+",result="+ result+",lockvalue="+lockValue);
        return result;
    }

    /**
     * 获取锁
     * @param lockKey
     * @param lockValue
     * @return
     */
    public boolean lock(String lockKey,String lockValue){
        boolean result=false;
        try(Jedis resource = redisPool.getResource()){
            String set = resource.set(lockKey, lockValue, "NX", "PX", DEFAULT_LOCK_TIMEOUNT);
            result = "OK".equals(set);
        }catch (Exception e){
            LogUtils.error("--->>lock excption--->>key=" + lockKey, e);
        }
        LogUtils.audit("--->>lock result--->>key=" + lockKey+",result="+ result+",lockvalue="+lockValue);
        return result;
    }

    /**
     * 释放锁
     * @param lockKey
     * @param lockValue
     * @return
     */
    public boolean unlock(String lockKey,String lockValue ){
        boolean result=false;
        String value=null;
        try(Jedis resource = redisPool.getResource()){
            value = resource.get(lockKey);
            if(null==value){
                result= true;
            }else {
                if (lockValue.equals(value)) {
                    result = resource.del(lockKey) > 0l;
                } else {
                    result = true;
                }
            }
        }catch (Exception e){
            LogUtils.error("--->>unlock excption--->>key=" + lockKey, e);
        }
        LogUtils.audit("--->>unlock result--->>key=" + lockKey+",result="+result+",value="+value+",unluckValue="+lockValue);
        return result;
    }
}

<pre style="font-family: 宋体; font-size: 13.5pt; background-color: rgb(255, 255, 255);"><pre name="code" class="java">import java.math.BigDecimal;

import com.nonobank.app.system.dto.SystemMonthRateDescriptionDTO;
import com.nonobank.app.utils.constants.ConstantForMonthRate;

public class StringUtils {
    public static boolean isEmpty(String str) {
        return org.springframework.util.StringUtils.isEmpty(str);
    }

    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 手机号取前3后4位 其他打*，如136****0055
     */
    public static String buildMobileString(String mobile) {

        String res = mobile.substring(0, 3) + "****" + mobile.substring(7, 11);
        return res;

    }

    public static String getNullToDefaultValue(String value, String defaultValue) {
        if (StringUtils.isEmpty(value)) {
            return defaultValue;
        }
        return value;
    }

    public static String mergeMonthDescription(SystemMonthRateDescriptionDTO dto) {

        String resDescription = "";
        String mergePattern = dto.getMergePattern();
        if (mergePattern.equals(ConstantForMonthRate.MERGE_PATTERN1)) {
            resDescription = dto.getBaseRate() + "%+" + dto.getMonthRate()
                    + "%";
        } else if (mergePattern.equals(ConstantForMonthRate.MERGE_PATTERN2)) {
            resDescription = new BigDecimal(dto.getBaseRate())
                    .add(new BigDecimal(dto.getMonthRate())) + "%";
        }
        if (dto.getIsMergeSalaryRate()) {
            resDescription += "+加薪" + dto.getSalaryRate() + "%";
        }

        return resDescription;

    }

    public static String getStringWithDefault(String value, String defaultStr) {
        if (StringUtils.isEmpty(value)) {
            return defaultStr;
        } else {
            return value;
        }
    }

}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {

    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {

        }
        return null;
    }

    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {

        }
        return null;
    }

}



 

 

 


 

                

        

        

    

  


    

      

        

            

              
                
                  天使没吃饱
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
redisUtil

				
			

			

				

					weixin_58361879的博客
				

				

					03-16
					
					419
					
				

			

		

		

			
				
import com.chengze.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOpera...

			
		

	



                

              
                



	

		

			

				
					
Redis-RedisUtils工具类

				
			

			

				

					m0_38045882的博客
				

				

					05-24
					
					9927
					
				

			

		

		

			
				
概述：

       本文不对redis再做相关详细的介绍，有关redis的相关基础知识及安装，数据结构，命令等请参考菜鸟教程中redis的相关介绍，通俗易懂。本篇文章仅仅针对实际中的开发对redis的操作进行封装。该工具类在jedis对redis操作封装的基础上近一步进行封装，在实际的开发中直接调用即可。由于方法太多，过于详细，在实际项目中可截取部分方法进行使用。由于该工具类中在加载redis...

			
		

	



                


  
              

                


	

		

			

				
					
redisUtil工具包

				
			

			

				

					10-29
				

			

		

		

			
				
1、这个是针对Redis服务器，针对Java开发的RedisUtil工具包类
2、每个方法都有注释和说明
3、每个封装参数都是多态，为Java开发者提供了效率很不错的一个
    RedisUtil工具类

			
		

	





	

		

			

				
					
RedisUtil

				
			

			

				

					三年学说话，一生学闭嘴
				

				

					11-25
					
					569
					
				

			

		

		

			
				
redisUtil

			
		

	



		

			
		



	

		

			

				
					
Redis工具类分享

					
最新发布

				
			

			

				

					weixin_71901717的博客
				

				

					07-08
					
					265
					
				

			

		

		

			
				
【代码】Redis工具类分享。

			
		

	





	

		

			

				
					
RedisUtils

				
			

			

				

					的博客
				

				

					04-10
					
					287
					
				

			

		

		

			
				
public class RedisService { 
    private static RedisService redisService ;

public JedisPool jedisPool;


public RedisService(){
    redisinit();
}
public static RedisService getInstance(){
    synch...

			
		

	





	

		

			

				
					
redis.set方法详解

				
			

			

				

					weixin_30951743的博客
				

				

					03-14
					
					2719
					
				

			

		

		

			
				
String set(String key, String value, String nxxx, String expx, long time);该方法是： 存储数据到缓存中，并制定过期时间和当Key存在时是否覆盖。
     nxxx： 只能取NX或者XX，如果取NX，则只有当key不存在是才进行set，如果取XX，则只有当key已经存在时才进行set     expx： 只能取EX或者PX...

			
		

	





	

		

			

				
					
redis utils 工具类

				
			

			

				

					07-08
				

			

		

		

			
				
下面我们将详细探讨RedisUtils工具类的关键知识点。  1. **Jedis库的使用**  RedisUtils通常依赖于Jedis，这是一个Java语言编写的Redis客户端。通过Jedis，我们可以实现连接Redis服务器、执行各种命令（如GET、SET、...

			
		

	





	

		

			

				
					
springboot  集成封装redis工具类redisUtils和单元测试

				
			

			

				

					09-13
				

			

		

		

			
				
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。

			
		

	





	

		

			

				
					
redisUtils工具类的使用

				
			

			

				

					04-26
				

			

		

		

			
				
RedisUtils工具类是Java开发中常见的一种封装了Redis操作的工具类，主要用于简化Redis数据库的存取操作。Redis是一个高性能的键值存储系统，广泛应用于缓存、消息队列、分布式锁等多种场景。在实际开发中，为了提高...

			
		

	





	

		

			

				
					
java RedisUtil工具类

				
			

			

				

					09-26
				

			

		

		

			
				
该工具类是包含：redis String，map，set，list 4种数据类型的常用操作方法。

			
		

	





	

		

			

				
					
RedisUtil.java 对redis一些操作的工具类, 具体看资源描述

				
			

			

				

					04-01
				

			

		

		

			
				
RedisUtil 实现了对redis的保存, 修改, 删除, 获取, 判断是否存在和 获取Redis 信息

			
		

	





	

		

			

				
					
可能是方法最全Redis静态工具类（RedisUtils.java）

				
			

			

				

					06-28
				

			

		

		

			
				
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！

			
		

	





	

		

			

				
					
RedisUtils.java

				
			

			

				

					05-09
				

			

		

		

			
				
基于spring和redis的redisTemplate工具类，针对redisTemplate的一些封装，包含一些日常比较容易用到的一些通用方法。

			
		

	





	

		

			

				
					
Redis学习手册(Set数据类型)

				
			

			

				

					hujiao_jingling的专栏
				

				

					05-15
					
					1万+
					
				

			

		

		

			
				
一、概述：

      在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要说明的是，这些操作的时间复杂度为O(1)，即常量时间内完成次操作。Set可包含的最大元素数量是4294967295。
      和List类型不同的是，Set集合中不允许出现重复的元素，这一点和C++标准库中

			
		

	





	

		

			

				
					
Redis工具类封装RedisUtils

					
热门推荐

				
			

			

				

					IT小跟班
				

				

					02-26
					
					3万+
					
				

			

		

		

			
				
本文参考：https://blog.it-follower.com/posts/2563248908.html

SpringBoot项目集成Redis相当简单，只需要pom中加入对应依赖


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>sp...

			
		

	





	

		

			

				
					
Redis通配符Key的使用并实现字符串（String）和哈希（Hash）的批量删除

				
			

			

				

					pan_junbiao的博客
				

				

					12-23
					
					9251
					
				

			

		

		

			
				
1、Redis的通配符

在 Redi s中，允许使用模糊查询 key。

Redis 支持3种通配符： *、?、[ ]

*：通配任意多个字符。

?：通配单个字符。

[ ]：通配括号内的某1个字符。



2、Redis Keys 命令

Redis 中的 Keys 命令：用于查找所有符合给定模式 pattern 的 key。

返回值：符合给定模式的 key 列表 (Array)。

【示例】Redis 中使用 Keys 命令和通配符进行查询。





3、Java中使用Redis通配符

R..

			
		

	





	

		

			

				
					
redisutils lock

				
			

			

				

					05-10
				

			

		

		

			
				
RedisUtils Lock是一个非常重要的工具，它提供了对Redis分布式锁的高效操作。

RedisUtils Lock的应用场景非常广泛，一般用于实现分布式环境下的资源互斥访问。在多线程、多进程、分布式系统中，为了避免数据竞争等问题，一般会采用锁等机制防止多个进程同时对同一资源进行操作。

RedisUtils Lock是基于Redis的SETNX指令实现的，它利用了Redis的原子性和单线程特性，拥有很高的性能和可靠性。在RedisUtils Lock的实现中，当一个线程占用了锁并且在使用资源时，其他线程是无法获取锁的，必须等待该线程释放锁后才能获取锁并执行相应的操作。

RedisUtils Lock的优点是：

1. 高效性：Redis是单线程的，因此使用RedisUtils Lock可以避免线程切换所带来的开销。

2. 可靠性：RedisUtils Lock采用的是SETNX指令实现的锁，具有很高的原子性和可靠性。

3. 易于使用：RedisUtils Lock封装了Redis的锁操作，使用起来非常方便。

4. 支持可重入：RedisUtils Lock支持可重入调用，在同一线程内多次加锁和释放锁。

RedisUtils Lock的缺点是：

1. 可能出现死锁：如果一个线程在加锁之后没有执行解锁操作，就会导致其他线程一直等待，从而出现死锁。

2. 不支持自旋锁：RedisUtils Lock采用的是阻塞锁，如果获取锁失败，则会一直阻塞等待。这种方式会占用线程资源，因此不适用于比较耗时的操作。

总之，RedisUtils Lock是一个非常实用的分布式锁工具，可以有效避免多线程、多进程、分布式系统中的资源竞争问题，具有很高的性能和可靠性。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值