缓存redis的处理

package me.explain.caption.common;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.SerializeWriter;
/**
 * redis 抽象类
 * 
 * @author 杨中仁
 * 
 *         编辑时间：2016年5月2日11:02:56
 * 
 */
public abstract class IBaseRedisCache {
 @Autowired
 protected RedisTemplate<String, Serializable> redisTemplate;
 public RedisTemplate<String, Serializable> getRedisTemplate() {
  return redisTemplate;
 }
 public void setRedisTemplate(RedisTemplate<String, Serializable> redisTemplate) {
  this.redisTemplate = redisTemplate;
 }
 /**
  * 获取 RedisSerializer
  */
 protected RedisSerializer<String> getRedisSerializer() {
  return redisTemplate.getStringSerializer();
 }
 protected static final long ONE_WEEK_CACHE_TIME = 7 * 24 * 60 * 60l;
 protected static final long ONE_DAY_CACHE_TIME = 24 * 60 * 60l;
 protected static final long ONE_HOUR_CACHE_TIME = 60 * 60l;
 protected static final long HALF_HOUR_CACHE_TIME = 30 * 60l;
 protected static final long FIFTEEN_MIN_CACHE_TIME = 60 * 15l;
 protected static final long FIVE_MIN_CACHE_TIME = 60 * 5l;
 protected static final long TEN_MIN_CACHE_TIME = 60 * 10l;
 protected static final long ONE_MIN_CACHE_TIME = 60 * 1l;
 protected static final long ONE_MONTH_CACHE_TIME = 30 * 24 * 60 * 60l;
 protected static final long FRAMEWORK_REDIS_DEFAULT_TIME = 7 * 24 * 60 * 60l;
 protected static final Long DAY_SECONDS = 24 * 60 * 60l;
 protected static final Integer REDIS_MGET_LIMIT = 10;
 protected static final Long REDIS_DEFAULT_CACHE_TIME = 1209600000l;
 protected static final Long MYSQL_INT_MAX_VALUE = 4294967295l;
 
 protected String generateCacheKey(String namespace, Object... keys) {
  StringBuffer out = new StringBuffer();
  out.append(namespace);
  out.append(":");
  for (int i = 0; i < keys.length; i++) {
   out.append(keys[i]);
   if (i != keys.length - 1) {
    out.append("_");
   }
  }
  return out.toString();
 }
 protected void putIntoCache(final String key, final Object value, final long expireTime) {
  this.redisTemplate.execute(new RedisCallback<Object>() {
   public Object doInRedis(RedisConnection connection) throws DataAccessException {
    SerializeWriter out = new SerializeWriter();
    JSONSerializer serializer = new JSONSerializer(out);
    serializer.write(value);
    connection.set(key.getBytes(), out.toBytes("utf-8"));
    connection.expire(key.getBytes(), expireTime);
    return Boolean.valueOf(true);
   }
  });
 }
 protected void putIntoCache(String key, Object value) {
  putIntoCache(key, value, FRAMEWORK_REDIS_DEFAULT_TIME);
 }
 protected void clearCache(final String key) {
  this.redisTemplate.execute(new RedisCallback<Object>() {
   public Object doInRedis(RedisConnection connection) throws DataAccessException {
    connection.del(new byte[][] { key.getBytes() });
    return Boolean.valueOf(true);
   }
  });
 }
 protected void clearCacheStartWith(final String key) {
  this.redisTemplate.execute(new RedisCallback<Object>() {
   public Object doInRedis(RedisConnection connection) throws DataAccessException {
    Set<? extends byte[]> keySet = connection.keys((key + "*").getBytes());
    if (keySet != null) {
     for (byte[] k : keySet) {
      connection.del(new byte[][] { k });
     }
    }
    return Boolean.valueOf(true);
   }
  });
 }
 protected <T> T getFromCache(final String key, final Class<T> clazz) {
  return this.redisTemplate.execute(new RedisCallback<T>() {
   public T doInRedis(RedisConnection connection) throws DataAccessException {
    byte[] out = connection.get(key.getBytes());
    if (out == null) {
     return null;
    }
    return JSONObject.parseObject(out, clazz, new Feature[0]);
   }
  });
 }
 @SuppressWarnings("unchecked")
 protected <T> List<T> getListFromCache(final List<String> keys, final Class<T> clazz) {
  return (List<T>) this.redisTemplate.execute(new RedisCallback<Object>() {
   public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
    if (keys.size() == 0) {
     return new ArrayList<T>();
    }
    List<byte[]> keySet = new ArrayList<byte[]>();
    for (String key : keys) {
     keySet.add(key.getBytes());
    }
    List<Object> out = new ArrayList<Object>();
    Iterator<Object> i$;
    if (keySet.size() <= REDIS_MGET_LIMIT.intValue()) {
     List<byte[]> results = connection.mGet((byte[][]) keySet.toArray(new byte[keySet.size()][]));
     if (results == null) {
      return null;
     }
     for (byte[] result : results)
      if (result != null) {
       Object t = JSONObject.parseObject(result, clazz, new Feature[0]);
       out.add(t);
      }
    } else {
     connection.openPipeline();
     int limitCount = keySet.size() / REDIS_MGET_LIMIT.intValue();
     int leftCount = keySet.size() % REDIS_MGET_LIMIT.intValue();
     for (int i = 0; i < limitCount; i++) {
      connection.mGet((byte[][]) keySet
        .subList(i * REDIS_MGET_LIMIT.intValue(), (i + 1) * REDIS_MGET_LIMIT.intValue())
        .toArray(new byte[REDIS_MGET_LIMIT.intValue()][]));
     }
     if (leftCount > 0) {
      connection
        .mGet((byte[][]) keySet.subList(limitCount * REDIS_MGET_LIMIT.intValue(), keySet.size())
          .toArray(new byte[leftCount][]));
     }
     List<Object> results = connection.closePipeline();
     for (i$ = results.iterator(); i$.hasNext();) {
      Object object = i$.next();
      if (object != null) {
       for (byte[] o : (List<byte[]>) object) {
        if (o != null) {
         Object t = JSONObject.parseObject(o, clazz, new Feature[0]);
         out.add(t);
        }
       }
      }
     }
    }
    return (List<T>) out;
   }
  });
 }
 @SuppressWarnings("unchecked")
 protected <T> List<T> getListFromCache(final String key, final Class<T> clazz) {
  return (List<T>) this.redisTemplate.execute(new RedisCallback<Object>() {
   public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
    byte[] out = connection.get(key.getBytes());
    if (out == null) {
     return null;
    }
    return JSONObject.parseArray(new String(out), clazz);
   }
  });
 }
}

   对redis下面处理的封装。