一个redis使用工具类

package com.cheng.common.util.cache;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

import com.google.gson.Gson;

@Service("redisCacheUtil")
public class RedisCacheUtil<T>
{

 @Autowired
 private RedisTemplate redisTemplate;

private ValueOperations<String, String> valueOperations;

private HashOperations<String, String, Object> hashOperations;

private ListOperations<String, Object> listOperations;

private SetOperations<String, Object> setOperations;

private ZSetOperations<String, Object> zSetOperations;

@PostConstruct
public void postConstruct() {
    valueOperations =  redisTemplate.opsForValue();
    hashOperations = redisTemplate.opsForHash();
    listOperations = redisTemplate.opsForList();
    setOperations = redisTemplate.opsForSet();
    zSetOperations = redisTemplate.opsForZSet();
}   

 /**  默认过期时长，单位：秒 */
 public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
 /**  不设置过期时长 */
 public final static long NOT_EXPIRE = -1;
 private final static Gson gson = new Gson();

 /**
  * 判断缓存是否存在
  * @param key 缓存的键值
  * @return  boolean
  */
 public boolean hasKey(String key)
 {
     return redisTemplate.hasKey(key);
 }

 /**
  * 删除对象
  * @param key 缓存的键值
  */
 public void delete(String key)
 {
     boolean hasKey = redisTemplate.hasKey(key);
     if (hasKey) {
         redisTemplate.delete(key);
     }
 }

 /**
  * 缓存基本的对象，Integer、String、实体类等
  * @param key 缓存的键值
  * @param value 缓存的值
  * @return  缓存的对象
  */
 public <T> ValueOperations<String,T> setCacheObject(String key,T value)
 {

  ValueOperations<String,T> operation = redisTemplate.opsForValue();
  operation.set(key,value);
  return operation;
 }

 /**
  * 获得缓存的基本对象。
  * @param key  缓存键值
  * @param operation
  * @return   缓存键值对应的数据
  */
 public <T> T getCacheObject(String key/*,ValueOperations<String,T> operation*/)
 {
  ValueOperations<String,T> operation = redisTemplate.opsForValue();
  return operation.get(key);
 }

 /**
  * 缓存List数据
  * @param key  缓存的键值
  * @param dataList 待缓存的List数据
  * @return   缓存的对象
  */
 public <T> ListOperations<String, T> setCacheList(String key,List<T> dataList)
 {
  ListOperations listOperation = redisTemplate.opsForList();
  if(null != dataList)
  {
   int size = dataList.size();
   for(int i = 0; i < size ; i ++)
   {

    listOperation.rightPush(key,dataList.get(i));
   }
  }

  return listOperation;
 }

 /**
  * 获得缓存的list对象
  * @param key 缓存的键值
  * @return  缓存键值对应的数据
  */
 public <T> List<T> getCacheList(String key)
 {
  List<T> dataList = new ArrayList<T>();
  ListOperations<String,T> listOperation = redisTemplate.opsForList();
  Long size = listOperation.size(key);

  for(int i = 0 ; i < size ; i ++)
  {
   dataList.add((T) listOperation.leftPop(key));
  }

  return dataList;
 }

 /**
  * 缓存Set
  * @param key  缓存键值
  * @param dataSet 缓存的数据
  * @return   缓存数据的对象
  */
 public <T> BoundSetOperations<String,T> setCacheSet(String key,Set<T> dataSet)
 {
  BoundSetOperations<String,T> setOperation = redisTemplate.boundSetOps(key);
  /*T[] t = (T[]) dataSet.toArray();
    setOperation.add(t);*/

  Iterator<T> it = dataSet.iterator();
  while(it.hasNext())
  {
   setOperation.add(it.next());
  }

  return setOperation;
 }

 /**
  * 获得缓存的set
  * @param key
  * @param operation
  * @return
  */
 public Set<T> getCacheSet(String key/*,BoundSetOperations<String,T> operation*/)
 {
  Set<T> dataSet = new HashSet<T>();
  BoundSetOperations<String,T> operation = redisTemplate.boundSetOps(key); 

  Long size = operation.size();
  for(int i = 0 ; i < size ; i++)
  {
   dataSet.add(operation.pop());
  }
  return dataSet;
 }

 /**
  * 缓存Map
  * @param key
  * @param dataMap
  * @return
  */
 public <T> HashOperations<String,String,T> setCacheMap(String key,Map<String,T> dataMap)
 {

  HashOperations hashOperations = redisTemplate.opsForHash();
  if(null != dataMap)
  {

   for (Map.Entry<String, T> entry : dataMap.entrySet()) { 

    /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */
    hashOperations.put(key,entry.getKey(),entry.getValue());
   } 

  }

  return hashOperations;
 }

 /**
  * 缓存Map
  * @param key
  * @param dataMap
  * @return
  */
 public <T> HashOperations<String,String,T> setCacheMap(String key, String mapKey, String mapValue)
 {

  HashOperations hashOperations = redisTemplate.opsForHash();
  if(StringUtils.isNotBlank(mapKey))
  {
    /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */
    hashOperations.put(key, mapKey, mapValue);
  }

  return hashOperations;
 }

 /**
  * 获得缓存的Map
  * @param key
  * @param hashOperation
  * @return
  */
 public <T> Map<String,T> getCacheMap(String key/*,HashOperations<String,String,T> hashOperation*/)
 {
  Map<String, T> map = redisTemplate.opsForHash().entries(key);
  /*Map<String, T> map = hashOperation.entries(key);*/
  return map;
 }

 /**
  * 获得缓存的Map
  * @param key
  * @param hashOperation
  * @return
  */
 public T getCacheMapValue(String key, String mapKey)
 {
  T value = (T) redisTemplate.opsForHash().entries(key).get(mapKey);
  /*Map<String, T> map = hashOperation.entries(key);*/
  return value;
 }

 /**
  * 删除对象
  * @param key 缓存的键值
  * @param key 缓存的map键值
  */
 public void deletetCacheMap(String key, String mapKey)
 {
     HashOperations hashOperations = redisTemplate.opsForHash();
     if(hashOperations.hasKey(key, mapKey)){
         hashOperations.delete(key, mapKey);
     }
 }

 /**
  * 缓存Map
  * @param key
  * @param dataMap
  * @return
  */
 public <T> HashOperations<String,Integer,T> setCacheIntegerMap(String key,Map<Integer,T> dataMap)
 {
  HashOperations hashOperations = redisTemplate.opsForHash();
  if(null != dataMap)
  {

   for (Map.Entry<Integer, T> entry : dataMap.entrySet()) { 

    /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */
    hashOperations.put(key,entry.getKey(),entry.getValue());
   } 

  }

  return hashOperations;
 }

 /**
  * 获得缓存的Map
  * @param key
  * @param hashOperation
  * @return
  */
 public <T> Map<Integer,T> getCacheIntegerMap(String key/*,HashOperations<String,String,T> hashOperation*/)
 {
  Map<Integer, T> map = redisTemplate.opsForHash().entries(key);
  /*Map<String, T> map = hashOperation.entries(key);*/
  return map;
 }
//添加新的缓存工具类
 /**
  * 从Redis中获取对象
  *
  * @param key 待获取数据的key
  * @return 返回key对应的对象
  */
 public Object getObject(String key) throws Exception {
     Object object = null;
     try {
         String serializeObj = get(key);
         if (null == serializeObj || serializeObj.length() == 0) {
             object = null;
         } else {
             object = SerializeUtil.deserialize(serializeObj);
         }
     }  catch (Exception e) {
         throw e;
     }
     return object;
 }

/**
  * 保存对象到Redis 对象不过期
  *
  * @param key    待缓存的key
  * @param object 待缓存的对象
  * @return 返回是否缓存成功
  */
 public boolean setObject(String key, Object object) throws Exception {
     return setObject(key, object, -1);
 }

 /**
  * 保存对象到Redis 并设置超时时间
  *
  * @param key     缓存key
  * @param object  缓存对象
  * @param timeout 超时时间
  * @return 返回是否缓存成功
  * @throws Exception 异常上抛
  */
 public boolean setObject(String key, Object object, int timeout) throws Exception {
     String value = SerializeUtil.serialize(object);
     boolean result = false;
     try {
         //为-1时不设置超时时间
         if (timeout != -1) {
             set(key,value,timeout);
         } else {
             set(key,value);
         }
         result = false;
     } catch (Exception e) {
         throw e;
     }
     return  result;
 }
 public String get(String key) {
     return get(key, NOT_EXPIRE);
 }

 public String get(String key, long expire) {
     String value = valueOperations.get(key);
     if(expire != NOT_EXPIRE){
         redisTemplate.expire(key, expire, TimeUnit.SECONDS);
     }
     return value;
 }
 public void set(String key, Object value, long expire){
     valueOperations.set(key, toJson(value));
     if(expire != NOT_EXPIRE){
         redisTemplate.expire(key, expire, TimeUnit.SECONDS);
     }
 }

 /**
  * Object转成JSON数据
  */
 private String toJson(Object object){
     if(object instanceof Integer || object instanceof Long || object instanceof Float ||
             object instanceof Double || object instanceof Boolean || object instanceof String){
         return String.valueOf(object);
     }
     return gson.toJson(object);
 }
 public void set(String key, Object value){
     set(key, value, DEFAULT_EXPIRE);
 }
}
时间： 2024-08-29 06:37:02

一个redis使用工具类的相关文章

spring boot 结合Redis 实现工具类

自己整理了 spring boot 结合 Redis 的工具类引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId></dependency>加入配置 # Redis数据库索引(默认为0)spring.redis.database=0# Redis服务器地址

Android 分享一个SharedPreferences的工具类,方便保存数据

我们平常保存一些数据,都会用到SharedPreferences,他是保存在手机里面的,具体路径是data/data/你的包名/shared_prefs/保存的文件名.xml, SharedPreferences的使用也很简单,我自己就写了一个SharedPreferences的工具类,然后就保存在这里,等自己以后需要保存数据直接从这里copy代码,哈哈 工具类如下 [java] view plaincopy package com.example.shortcut; import androi

自己用反射写的一个request.getParameter工具类

适用范围:当我们在jsp页面需要接收很多值的时候,如果用request.getParameter(属性名)一个一个写的话那就太麻烦了,于是我想是 否能用反射写个工具类来简化这样的代码,经过1个小时的代码修改调试,终于雏形出来了,很高兴调试成功,呵呵,代码贴出来. package com.letv.uts2.utcServer.util; import org.slf4j.Logger;import org.slf4j.LoggerFactory; import java.lang.reflect

redis缓存工具类，提供序列化接口

1.序列化工具类 1 package com.qicheshetuan.backend.util; 2 3 import java.io.ByteArrayInputStream; 4 import java.io.ByteArrayOutputStream; 5 import java.io.ObjectInputStream; 6 import java.io.ObjectOutputStream; 7 8 public class SerializeUtil { 9 10 //序列化 11

一个python爬虫工具类

写了一个爬虫工具类. # -*- coding: utf-8 -*- # @Time : 2018/8/7 16:29 # @Author : cxa # @File : utils.py # @Software: PyCharm from retrying import retry from decorators.decorators import decorator from glom import glom from config import headers import datetim

自己封装的一个mysql数据库工具类

<?php class SqlHelper{ public $conn; //连接资源变量 public $host; //主机 public $user;  //用户名 public $password; //密码 public $db; //数据库 function __construct($host="localhost",$user="root",$password,$db){ $this->host=$host; $this->user=

SpringBoot整合Redis并完成工具类

SpringBoot整合Redis的资料很多,但是我只需要整合完成后,可以操作Redis就可以了,所以不需要配合缓存相关的注解使用(如@Cacheable),而且我的系统框架用的日志是log4j,不是SpringBoot默认的Logback.通过查询资料我完成了Redis整合,并写了Redis操作工具类.特意在此记录一下,分享给大家,也方便以后查阅. 1.SpringBoot版本如下 <parent> <groupId>org.springframework.boot</gr

单机版 RedisUtils（{基本操作封装工具类}）【三】

<!--集成的RedisJAR--> <!--引入jedis需的jar包--> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <!--Spring整合jedis的依赖--> <depen

[javaSE] 集合工具类（Collections-sort）

java为我们提供了一个集合的工具类,方便我们对集合进行操作,里面的方法都是静态方法. Collections.sort()方法,参数:List<T>集合对象,这个对象带着泛型,是为了保证集合中的元素具备可比较性,因此这个返回值的泛型就会特殊点, <T extends Comparable <? super T>> 默认排序字符串,是按照字母的排列顺序 如果是中文,默认是按照ascii编码进行排序的 自定义一个比较器,实现按照字符串的长度进行排序 定义一个类StrCom