redis数据操作封装（RedisTemplate）

以下是redis数据的操作封装 大概为（redsi对数据的增删查）几乎封装的大部分的方法 只有一小部分的方法没有写进来

package com.software.common;

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

import javax.annotation.Resource;

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.HashOperations;
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;

@Service
public class ReidsImpl {
	@Resource 
	private RedisTemplate<Object, Object> redisTemplate;
	
	
//	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();
	}
	
	
	
	
	
	//字符串操作
	
	/**
	 * set字符串
	 * @param key
	 * @param value
	 */
	public void set(String key,Object value) {
		redisTemplate.opsForValue().set(key, value);
		
	}
	
	/**
	 * set字符串 并加上失效时间  以豪秒为单位
	 * @param key
	 * @param value
	 * @param timeout 失效时间 单位为豪秒
	 */
	public void set(Object key,Object value,Integer timeout) {
		redisTemplate.opsForValue().set(key, value,timeout,TimeUnit.MILLISECONDS);
	}
	
	/**
	 * 当key不存在时 设置key value
	 * @param key
	 * @param value
	 */
	public void setNx(String key,Object value) {
		redisTemplate.opsForValue().setIfAbsent(key, value);
	}
	
	
	/**
	 * 根据key获取value
	 * @param key
	 * @return
	 */
	public Object get(String key) {
		return redisTemplate.opsForValue().get(key);
	}
	
	/**
	 * 获取所有(一个或多个)给定 key 的值
	 * @param key
	 * @return
	 */
	public List<Object> mGet(String... keys){
		return redisTemplate.opsForValue().multiGet(CollectionUtils.arrayToList(keys));
	}
	
	/**
	 * 同时设置多个key，value
	 * @param map
	 */
	public void mSet(Map<String, Object> map) {
		redisTemplate.opsForValue().multiSet(map);
	}
	
	/**
	 * 所有给定的key都不存在时，设置多个key，value
	 * @param map
	 */
	public void mSetNx(Map<String, Object> map) {
		redisTemplate.opsForValue().multiSetIfAbsent(map);
	}
	
	
	/**
	 * 通过key返回value的长度
	 * @param key
	 * @return
	 */
	public int strLength(String key) {
		return redisTemplate.opsForValue().get(key).toString().length();
	}
	
	/**
	 * 当前key存在时  向这个key对应value的默认追加上此字符
	 * @param key
	 * @param value 要追加的字符
	 */
	public void appendStr(Object key,String value){
		 redisTemplate.opsForValue().append(key, value);
	}
	
	
	//Hash操作
	
	/**
	 * 删除key中指定的hashkey的值  相当于一个key中存储着map值 这个方法就是删除这个key中的map里面的一个或多个key
	 * @param key
	 * @param hashKeys
	 */
	public void hdel(Object key,String...hashKeys) {
		 redisTemplate.opsForHash().delete(key, hashKeys);
	}
	
	/**
	 * 添加一个hash值
	 * 
	 * @param key
	 * @param hashKey 相当于 map中的key
	 * @param value 存储的值 相当于map中的value
	 */
	public void put(Object key,String hashKey,Object value) {
		redisTemplate.opsForHash().put(key, hashKey, value);
	}
	
	   
	/**
	 * 添加一个map
	 * @param key
	 * @param map
	 */
	public void putAll(String key,Map<Object, Object> map) {
		redisTemplate.opsForHash().putAll(key, map);
	}
	
	/**
	 * 获取redis中的map
	 * @param key
	 * @return
	 */
	public Map<Object ,Object> getRedisMap(String key){
		return redisTemplate.opsForHash().entries(key);
	}
	
	/**
	 * 返回这个key里面所有hashKeys的值
	 * @param key
	 * @param hashKeys
	 * @return
	 */
	public List<Object> multiGet(String key,String...hashKeys) {
		return redisTemplate.opsForHash().multiGet(key, CollectionUtils.arrayToList(hashKeys));
	}
	
	
	
	/**
	 * 返回这个key中的所有value
	 * @param key
	 * @return
	 */
	public List<Object> getValues(Object key){
		return redisTemplate.opsForHash().values(key);
	}
	
	/**
	 * 判断key中的hashKey是否存在
	 * @param key
	 * @param hashKey
	 */
	public Boolean hashMapKey(Object key,String hashKey) {
		return redisTemplate.opsForHash().hasKey(key, hashKey);
	}
	
	
	
	//list操作
	
	/**
	 * 从左入栈
	 * @param key
	 * @param value
	 */
	public void lpush(String key,Object value) {
		redisTemplate.opsForList().leftPush(key, value);
	}
	
	/**
	 * 从右入栈
	 * @param key
	 * @param value
	 */
	public void rpush(String key,Object value) {
		redisTemplate.opsForList().rightPush(key, value);
	}
	
	
	/**
	 * 从左出栈
	 * @param key
	 * @return
	 */
	public Object lPop(String key) {
		return redisTemplate.opsForList().leftPop(key);
	}
	
	/**
	 * 从右出栈
	 * @param key
	 * @return
	 */
	public Object rPop(String key) {
		return redisTemplate.opsForList().rightPop(key);
	}
	
	
	/**
	 * 获取该key index处的元素
	 * @param key
	 * @param index
	 * @return
	 */
	public Object getKeyIndex(String key,int index) {
		return redisTemplate.opsForList().index(key, index);
	}
	
	/**
	 * 获取列表的长度
	 * @param key
	 * @return
	 */
	public Long getLength(String key) {
		return redisTemplate.opsForList().size(key);
	}
	
	/**
	 * 获取key中下标从start到end处的值
	 * @param key
	 * @param start 开始下标
	 * @param end  结束下标
	 * @return
	 */
	public List<Object> range(String key,int start,int end){
		return redisTemplate.opsForList().range(key, start, end);
	}
	
	
	
	//set操作  无序集合
	
	/**
	 * 向集合中添加
	 * @param key
	 * @param values
	 */
	public void addSet(String key,Object...values) {
		redisTemplate.opsForSet().add(key, values);
	}
	
	/**
	 * 移除并取出第一个元素
	 * @param key
	 * @return
	 */
	public Object getSet(String key){
		return redisTemplate.opsForSet().pop(key);
	}
	
	/**
	 * 返回集合中所有的元素
	 * @param key
	 * @return
	 */
	public Set<Object> getSets(String key){
		return redisTemplate.opsForSet().members(key);
	}
	
	/**
	 * 返回指定数量的元素(随机)
	 * @param key
	 * @param count
	 * @return
	 */
	public List<Object> randomMembers(String key,int count){
		return redisTemplate.opsForSet().randomMembers(key, count);
	}
	
	/**
	 * 返回集合中的长度
	 * @param key
	 * @return
	 */
	public Long getSetsNum(String key){
		return redisTemplate.opsForSet().size(key);
	}
	
	/**
	 * 返回给定集合的差集（返回 key在otherKeys不存在的元素）
	 * @param key 主集合
	 * @param otherKeys 其他集合
	 * @return
	 */
	public Set<Object> difference(String key,String...otherKeys){
		return redisTemplate.opsForSet().difference(key, CollectionUtils.arrayToList(otherKeys));
	}
	
	/**
	 * 返回给定集合的交集（返回 key与otherKeys中共同存在的元素）
	 * @param key
	 * @param otherKeys
	 * @return
	 */
	public Set<Object> intersect(String key,String...otherKeys){
		return redisTemplate.opsForSet().intersect(key, CollectionUtils.arrayToList(otherKeys));
	}
	
	/**
	 * 返回给定集合的并集（key和otherKeys加起来的所有元素，共同拥有的元素只返回一个）
	 * @param key
	 * @param otherKeys
	 * @return
	 */
	public Set<Object> union(String key,String...otherKeys){
		return redisTemplate.opsForSet().union(key, CollectionUtils.arrayToList(otherKeys));
	}
	
	/**
	 * 返回集合中的所有元素
	 * @param key
	 * @return
	 */
	public Set<Object> members(String key){
		return redisTemplate.opsForSet().members(key);
	}
	
	/**
	 * 迭代集合中的元素
	 * @param key
	 * @return
	 */
	public Cursor<Object> scan(String key){
		return redisTemplate.opsForSet().scan(key, ScanOptions.NONE);
	}
	
	
	
	//zSet操作 有序集合
	
	/**
	 * 添加数据
	 * 
	 * 添加方式：
	 * 1.创建一个set集合
	 * Set<ZSetOperations.TypedTuple<Object>> sets=new HashSet<>();
	 * 2.创建一个有序集合
		ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>(value,排序的数值，越小越在前);
		4.放入set集合
		sets.add(objectTypedTuple1);
		5.放入缓存
		reidsImpl.Zadd("zSet", list);  
	 * @param key
	 * @param tuples
	 */
	public void Zadd(String key,Set<ZSetOperations.TypedTuple<Object>> tuples) {
		redisTemplate.opsForZSet().add(key, tuples);
	}

	/**
	 * 获取有序集合的成员数
	 * @param key
	 * @return
	 */
	public Long Zcard(String key) {
		return redisTemplate.opsForZSet().zCard(key);
	}
	
	/**
	 * 计算在有序集合中指定区间分数的成员数
	 * @param key
	 * @param min 最小排序分数
	 * @param max 最大排序分数
	 * @return
	 */
	public Long Zcount(String key,Double min,Double max) {
		return redisTemplate.opsForZSet().count(key, min, max);
	}
	
	/**
	 * 获取有序集合下标区间 start 至 end 的成员  分数值从小到大排列
	 * @param key
	 * @param start
	 * @param end
	 */
	public Set<Object> Zrange(String key,int start,int end) {
		return redisTemplate.opsForZSet().range(key, start, end);
	}
	
	/**
	 * 获取有序集合下标区间 start 至 end 的成员  分数值从大到小排列
	 * @param key
	 * @param start
	 * @param end
	 */
	public Set<Object> reverseRange(String key,int start,int end) {
		return redisTemplate.opsForZSet().reverseRange(key, start, end);
	}
	
	/**
	 * 返回 分数在min至max之间的数据 按分数值递减(从大到小)的次序排列。
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Set<Object> reverseRange(String key,Double min,Double max) {
		return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
	}
	
	/**
	 * 返回指定成员的下标
	 * @param key 
	 * @param value
	 * @return
	 */
	public Long Zrank(String key,Object value) {
		return redisTemplate.opsForZSet().rank(key, value);
	}
	
	/**
	 * 删除key的指定元素
	 * @param key
	 * @param values
	 * @return
	 */
	public Long ZremoveValue(String key,Object values) {
		return redisTemplate.opsForZSet().remove( key, values);
	}
	
	/**
	 * 移除下标从start至end的元素
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Long ZremoveRange(String key,int start,int end) {
		return redisTemplate.opsForZSet().removeRange(key, start, end);
	}
	
	/**
	 * 移除分数从min至max的元素
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Long ZremoveRangeByScore(String key,Double min,Double max) {
		return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
	}
	

	
}