一个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);
 }
}