springmvc中redis数据操作封装（RedisTemplate）

简单直接上代码

package com.xxxx.common;
 
import java.util.Collection;
import java.util.HashMap;
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 java.util.stream.Collectors;
 
import javax.annotation.Resource;
 
import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import redis.clients.jedis.Jedis;
 
@Service
public class ReidsImpl{
   
	@Resource 
	private RedisTemplate<Object, Object> redisTemplate;
	//此处用的hash存储的对象 所以加一个key
	private static final String objectKey="objectMapKey";
//	redisTemplate.opsForValue();//操作字符串
//	redisTemplate.opsForHash();//操作hash
//	redisTemplate.opsForList();//操作list
//	redisTemplate.opsForSet();//操作set
//	redisTemplate.opsForZSet();//操作有序set
	
	//key操作
	/**
	 * 删除key 可传多个key
	 * @param keys
	 */
	public void delete(String... keys) {
   
		redisTemplate.delete(CollectionUtils.arrayToList(keys));
	}
	
	/**
	 * 给指定的key设置过期时间  单位为毫秒
	 * @param key
	 * @param timeout 过期时间 单位是毫秒
	 */
	public void expire(String key,Integer timeout) {
   
		redisTemplate.expire(key, timeout, TimeUnit.MILLISECONDS);
	}
	
	
	/**
	 * 移除key的过期时间，将key永久保存
	 * @param key
	 */
	public void persist(String key) {
   
		redisTemplate.persist(key);
	}
	
	/**
	 * 检验该key是否存在 存在返回true
	 * @param key
	 */
	public boolean hasKey(String key) {
   
		return redisTemplate.hasKey(key);
	}
	
	/**
	 * 返回 key 所储存的值的类型
	 * @param key
	 * @return
	 */
	public DataType getType(String key) {
   
		return redisTemplate.type(key);
	}
	
	/**
	 * 从redis中随机返回一个key
	 * @return
	 */
	public Object redomKey() {
   
		return redisTemplate.randomKey();
	}
	
	
	
	//对象操作
	/**
	 * 字符串：存对象
	 * @param key
	 * @param value
	 */
	public void setObject(String key,Object value) {
   
		final byte[] values = SerializeUtil.serialize(value);
        redisTemplate.execute((RedisCallback<Void>) connection -> {
    connection.set(key.getBytes(), values);return null;});
	}
	
	/**
	 * 字符串：取对象
	 * @param key
	 * @param targetClass：实体对象
	 * @return
	 */
	public <T> T getObject(final String key, Class<T> targetClass) {
    
		
		byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(key.getBytes()));
	    if (result == null) {
    
	    	return null;
	    } 
	    return SerializeUtil.deserialize(result, targetClass);
	} 
	
	/**
	 *  字符串：存对象 并设置失效时间
	 * @param key
	 * @param value
	 * @param expireTime
	 */
	 public <T> void setObjectTime(String key, T value, final long expireTime) {
    
			 final byte[] values = SerializeUtil.serialize(value);
			 redisTemplate.execute((RedisCallback<Void>) connection -> {
    connection.setEx(key.getBytes(), expireTime, values);
	         return null;
		 });
	 }
	 
	 /**
	  * 字符串：存放多个对象
	  * @param key
	  * @param objList
	  */
	   public <T> void setList(String key, List<T> objList) {
    
			   final byte[] value = SerializeUtil.serializeList(objList);
			   redisTemplate.execute((RedisCallback<Void>) connection -> {
    connection.set(key.getBytes(), value);
	           return null;
		   });
	   }
	   
	   /**
	    * 取多个对象
	    * @param key
	    * @param targetClass
	    * @return
	    */
	   public <T> List<T> getList(final String key, Class<T> targetClass) {
   
		   byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(key.getBytes()));
	       if (result == null) {
    
	    	   return null;
	       } 
	       return SerializeUtil.deserializeList(result, targetClass);
	   }
	   
	   
	   /**
	     * 从hashMap中取出对象
	     *
	     * @param key
	     * @param hashKey
	     * @param targetClass
	     * @param <T>
	     * @return
	     */
	    public <T> T hGetObject(final String key, final String hashKey, Class<T> targetClass) {
   
	    	byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.hGet(key.getBytes(), hashKey.getBytes()));
	        if (result == null) {
   
	        	return null;
	        }
	        return SerializeUtil.deserialize(result, targetClass);
	    } 
	    
	    
	    /**
	     * 在hashMap中放入对象
	     *
	     * @param key
	     * @param hashKey
	     * @param obj
	     * @param <T>
	     * @return
	     */
	    public <T> boolean hSetObject(String key, String hashKey, T obj) {
   
	    	final byte[] value = SerializeUtil.serialize(obj);
	        return redisTemplate.execute( (RedisCallback<Boolean>) connection -> connection.hSet(key.getBytes(), hashKey.getBytes(), value));
	    }
	    /**
	     * 在hashMap中放入对象并设置失效时间
	     *
	     * @param key
	     * @param hashKey
	     * @param obj
	     * @param <T>
	     */
	    public <T> void hSetObjectTime(String key, String hashKey, T obj, long expireTime) {
   
	    	final byte[] value = SerializeUtil.serialize(obj);
	        redisTemplate.execute((RedisCallback<Void>) connection -> {
    
	        	connection.hSet(key.getBytes(