自定义redis的工具类

自定义redis工具类

import java.util.Collection;
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.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

/**
 * 
 * <redis 工具类>
 * <功能详细描述>
 * 
 * @author  dell
 * @version  [版本号, 2022年6月10日]
 * @see  [相关类/方法]
 */
@Component
public class RedisCache {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

//    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
//        this.redisTemplate = redisTemplate;
//    }
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
    	this.redisTemplate = redisTemplate;
    }

    /**
     * 指定缓存失效时间
     *
     * @param key 键
     * @param time 时间(秒)
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long time) {
        return expire(key, time, TimeUnit.SECONDS);
    }
    
    /**
     * 指定缓存失效时间
     *
     * @param key 键
     * @param time 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long time, final TimeUnit unit) {
    	try {
            if(time>0){
                redisTemplate.expire(key, time, unit);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
    	
    	return set(key, value, time, TimeUnit.SECONDS);
    }
    
    public boolean set(String key,Object value,long time, TimeUnit unit){
        try {
            if(time > 0){
                redisTemplate.opsForValue().set(key, value, time, unit);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 模糊查询获取key值
     * @param pattern
     * @return
     */
    public Set<?> keys(String pattern){
        return redisTemplate.keys(pattern);
    }

    /**
     * 使用Redis的消息队列
     * @param channel
     * @param message 消息内容
     */
    public void convertAndSend(String channel, Object message){
        redisTemplate.convertAndSend(channel,message);
    }


    /**
     * 根据起始结束序号遍历Redis中的list
     * @param listKey
     * @param start  起始序号
     * @param end  结束序号
     * @return
     */
    public List<Object> rangeList(String listKey, long start, long end) {
        //绑定操作
        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
        //查询数据
        return boundValueOperations.range(start, end);
    }
    /**
     * 弹出右边的值 --- 并且移除这个值
     * @param listKey
     */
    public Object rifhtPop(String listKey){
        //绑定操作
        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
        return boundValueOperations.rightPop();
    }

    //=========BoundListOperations 用法 End============

    /**
     * <处理缓存的Key>
     * <功能详细描述>
     * @param vals
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String handleCacheKey (String spliter, String ... vals) {
    	return String.join(spliter, vals);
    }
    
}

redis序列化配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis序列化配置类
 * @Description
 * @author 陌路
 * @date 2022-04-28
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lcf) {
        RedisTemplate<String, Object> restTemplate = new RedisTemplate<String, Object>();
        // 为String类型的key设置序列化
        restTemplate.setKeySerializer(new StringRedisSerializer());
        // 为String类型的value设置序列化
        restTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 为Hash类型的key设置序列化
        restTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 为Hash类型的value设置序列化
        restTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        restTemplate.setConnectionFactory(lcf);
        return restTemplate;
    }
}

redis工具类的封装

import java.time.Duration;
import java.util.Arrays;
import java.util.Collection;
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.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

/**
 * redis工具类
 * @Description
 * @author 陌路
 * @date 2022-04-28
 */
@Component
public class RedisUtils {

	@Resource
	private RedisTemplate<String, Object> redisTemplate;

	/******************************* String *******************************/

	/**
	 * @title 存储为JSON类型，并设置失效时间
	 * @param Duration.ofDays(0);     天
	 * @param Duration.ofHours(0L);   小时
	 * @param Duration.ofMinutes(0L); 分钟
	 * @param Duration.ofSeconds(0L); 秒
	 * @param Duration.ofMillis(0L);  毫秒
	 */
	public void setJsonObj(String key, Object obj, Duration timeout) {
		String jsonStr = ObjectUtils.toJSON(obj);
		if (ObjectUtils.isEmpty(timeout)) {
			this.redisTemplate.opsForValue().set(key, jsonStr);
		} else {
			this.redisTemplate.opsForValue().set(key, jsonStr, timeout);
		}
	}

	/**
	 * @title 存储为对象类型，并设置失效时间
	 * @param Duration.ofDays(0);     天
	 * @param Duration.ofHours(0L);   小时
	 * @param Duration.ofMinutes(0L); 分钟
	 * @param Duration.ofSeconds(0L); 秒
	 * @param Duration.ofMillis(0L);  毫秒
	 */
	public void setObj(String key, Object obj, Duration timeout) {
		if (ObjectUtils.isEmpty(timeout)) {
			this.redisTemplate.opsForValue().set(key, obj);
		} else {
			this.redisTemplate.opsForValue().set(key, obj, timeout);
		}
	}

	/**
	 * @title 存储为Long类型，并设置失效时间
	 * @param Duration.ofDays(0);     天
	 * @param Duration.ofHours(0L);   小时
	 * @param Duration.ofMinutes(0L); 分钟
	 * @param Duration.ofSeconds(0L); 秒
	 * @param Duration.ofMillis(0L);  毫秒
	 */
	public void setLong(String key, Long num, Duration timeout) {
		this.redisTemplate.opsForValue().set(key, num, timeout);
	}

	/**
	 * @title 存储为String类型，并设置失效时间
	 * @param Duration.ofDays(0);     天
	 * @param Duration.ofHours(0L);   小时
	 * @param Duration.ofMinutes(0L); 分钟
	 * @param Duration.ofSeconds(0L); 秒
	 * @param Duration.ofMillis(0L);  毫秒
	 */
	public void setStr(String key, String val, Duration timeout) {
		this.redisTemplate.opsForValue().set(key, val, timeout);
	}

	/**
	 * @title 存储多条数据
	 * @param map.put("name", "zs"); map.put("age", 18); // key - val
	 */
	public void setMap(Map<String, Object> map) {
		this.redisTemplate.opsForValue().multiSet(map);
	}

	/**
	 * @title 获取多条数据
	 * @param keys.add("name"); keys.add("age"); // 需要获取的key
	 */
	public List<Object> getMap(Collection<String> keys) {
		List<Object> multiGet = this.redisTemplate.opsForValue().multiGet(keys);
		return multiGet;
	}

	/**
	 * @title 存储为Long类型
	 */
	public void setLong(String key, Long num) {
		setLong(key, num, null);
	}

	/**
	 * @title 存储为对象类型
	 */
	public void setObj(String key, Object obj) {
		setObj(key, obj, null);
	}

	/**
	 * @title 存储为JSON类型
	 */
	public void setJsonObj(String key, Object obj) {
		setJsonObj(key, obj, null);
	}

	/**
	 * @title 存储为String类型
	 */
	public void setStr(String key, String val) {
		setStr(key, val);
	}

	/**
	 * @title 根据key获取String
	 */
	public String getStr(String key) {
		return ObjectUtils.getStr(this.redisTemplate.opsForValue().get(key));
	}

	/**
	 * @title 根据key获取JSON
	 */
	public String getJson(String key) {
		return getStr(key);
	}

	/**
	 * @title 根据key获取Object对象
	 */
	public Object getObj(String key) {
		return ObjectUtils.getObj(this.redisTemplate.opsForValue().get(key));
	}

	/**
	 * @title 根据key删除数据
	 */
	public boolean remove(String key) {
		if (ObjectUtils.isEmpty(key)) {
			return false;
		}
		return this.redisTemplate.delete(key);
	}

	/**
	 * @title 删除多条缓存数据
	 */
	public boolean remove(Collection<String> keys) {
		Long del = this.redisTemplate.delete(keys);
		if (del > 0) {
			return true;
		}
		return false;
	}

	/**
	 * @title 删除多条缓存数据
	 */
	public boolean remove(String... keys) {
		if (ObjectUtils.checkArr(keys)) {
			return false;
		}
		Set<String> set = new HashSet<String>(Arrays.asList(keys));
		return remove(set);
	}

	/******************************* List *******************************/

	/**
	 * @title list->左添加
	 */
	public void lPush(String key, Object val) {
		this.redisTemplate.opsForList().leftPush(key, val);
	}

	/**
	 * @title list->左添加，添加多条数据
	 * @return 添加条数
	 */
	public Long lPushAll(String key, Object... val) {
		Long count = this.redisTemplate.opsForList().leftPushAll(key, val);
		if (ObjectUtils.isBlank(count)) {
			return 0L;
		}
		return count;
	}

	/**
	 * @title list->左添加，将newVal添加到existVal的左边
	 * @Desc 左添加 第三个参数会被添加到第二个参数的左边
	 * @return 添加条数
	 */
	public Long lPush(String key, Object existVal, Object newVal) {
		Long count = this.redisTemplate.opsForList().leftPush(key, existVal, newVal);
		return count;
	}

	/**
	 * @title list->右添加
	 */
	public void rPush(String key, Object val) {
		this.redisTemplate.opsForList().rightPush(key, val);
	}

	/**
	 * @title list->右添加，添加多条数据
	 * @return 添加条数
	 */
	public Long rPushAll(String key, Object... val) {
		Long count = this.redisTemplate.opsForList().rightPushAll(key, val);
		if (ObjectUtils.isBlank(count)) {
			return 0L;
		}
		return count;
	}

	/**
	 * @title list->右添加，将newVal添加到existVal的右边
	 * @Desc 右添加 第三个参数会被添加到第二个参数的右边
	 * @return 添加条数
	 */
	public Long rPush(String key, Object existVal, Object newVal) {
		Long count = this.redisTemplate.opsForList().rightPush(key, existVal, newVal);
		return count;
	}

	/**
	 * @title list->获取指定索引位置的数据
	 * @Desc redis的key，开始索引，结束索引
	 * @return 获取到的数据集合
	 */
	public List<Object> getList(String key, long startIndex, long endIndex) {
		List<Object> list = this.redisTemplate.opsForList().range(key, startIndex, endIndex);
		return list;
	}

	/**
	 * @title list->获取List中的所有数据
	 * @return 获取到的数据集合
	 */
	public List<Object> getListAll(String key) {
		List<Object> list = this.redisTemplate.opsForList().range(key, 0, -1);
		return list;
	}

	/**
	 * @title list->获取List中的数据条数
	 * @return 数据条数
	 */
	public Long getListSize(String key) {
		Long size = this.redisTemplate.opsForList().size(key);
		return ObjectUtils.isBlank(size) ? 0L : size;
	}

	/**
	 * @title list->删除List中的数据
	 * @param redis的key，count删除的条数，val删除的值
	 * @return 删除的数据条数
	 */
	public Long removeList(String key, Long count, Object val) {
		Long rem = this.redisTemplate.opsForList().remove(key, count, val);
		return ObjectUtils.isBlank(rem) ? 0L : rem;
	}

	/**
	 * @title list->删除List中的数据
	 * @param redis的key，val删除的值，默认只删除一条
	 * @return 删除成功返回true，删除失败返回false
	 */
	public boolean removeList(String key, Object val) {
		Long rem = this.redisTemplate.opsForList().remove(key, 1, val);
		return ObjectUtils.isBlank(rem);
	}

	/**
	 * @title list->删除左边的第一条数据
	 * @param redis的key
	 * @return 返回值为删除的值
	 */
	public Object lPop(String key) {
		Object obj = this.redisTemplate.opsForList().leftPop(key);
		return obj;
	}

	/**
	 * @title list->删除右边的第一条数据
	 * @param redis的key
	 * @return 返回值为删除的值
	 */
	public Object rPop(String key) {
		Object obj = this.redisTemplate.opsForList().rightPop(key);
		return obj;
	}

	/******************************* Set *******************************/

	/**
	 * @title set->添加数据
	 * @param redis的key，数组
	 * @return 返回值为添加的条数
	 * @Desc 数据类型 ("redisKey", "val1", "val2", "val3"...)
	 */
	public Long sAdd(String key, Object[] obj) {
		if (ObjectUtils.isBlank(obj)) {
			return 0L;
		}
		return sAdds(key, obj);
	}

	/**
	 * @title set->多数据添加数据
	 * @param redis的key，数据值...
	 * @return 返回值为添加的条数
	 * @Desc 数据类型 ("redisKey", "val1", "val2", "val3"...)
	 */
	public Long sAdds(String key, Object... obj) {
		if (ObjectUtils.isBlank(obj)) {
			return 0L;
		}
		Long count = this.redisTemplate.opsForSet().add(key, obj);
		return count;
	}

	/**
	 * @title set->获取数据
	 * @param redis的key
	 * @return 返回Set集合
	 * @Desc 数据类型 ("redisKey", "val1", "val2", "val3"...)
	 */
	public Set<Object> getSet(String key) {
		if (ObjectUtils.isBlank(key)) {
			return new HashSet<Object>();
		}
		Set<Object> set = this.redisTemplate.opsForSet().members(key);
		return set;
	}

	/**
	 * @title set->获取set集合中的数据条数
	 * @param redis的key
	 * @return 返回Set集合的数据条数
	 * @Desc 数据类型 ("redisKey", "val1", "val2", "val3"...)
	 */
	public Long getSetSize(String key) {
		if (ObjectUtils.isBlank(key)) {
			return 0L;
		}
		Long size = this.redisTemplate.opsForSet().size(key);
		return ObjectUtils.isBlank(size) ? 0L : size;
	}

	/**
	 * @title set->删除set集合中的数据
	 * @param redis的key
	 * @return 返回删除的条数
	 */
	public Long removeSet(String key, Object... obj) {
		if (ObjectUtils.isBlank(obj)) {
			return 0L;
		}
		Long rem = this.redisTemplate.opsForSet().remove(key, obj);
		return ObjectUtils.isBlank(rem) ? 0L : rem;
	}

	/******************************* ZSet *******************************/

	/**
	 * @title ZSet->添加ZSet数据
	 * @param redis的key
	 * @return 成功返回true，失败返回false
	 */
	public boolean addZSet(String key, Object obj, double val) {
		if (ObjectUtils.isBlank(key)) {
			return false;
		}
		return this.redisTemplate.opsForZSet().add(key, obj, val);
	}

	/**
	 * @title ZSet->添加ZSet数据
	 * @param redis的key
	 * @return 成功返回添加的条数
	 */
	public Long addZSet(String key, Map<String, Double> map) {
		if (ObjectUtils.isBlank(map)) {
			return 0L;
		}
		Set<ZSetOperations.TypedTuple<Object>> tupleSet = new HashSet<>();
		for (String k : map.keySet()) {
			tupleSet.add(new DefaultTypedTuple<>(k, map.get(k)));
		}
		Long count = this.redisTemplate.opsForZSet().add(key, tupleSet);
		return ObjectUtils.isBlank(count) ? 0L : count;
	}

	/**
	 * @title ZSet->获取指定的ZSet数据
	 * @param redis的key，开始索引，结束索引
	 * @return 获取到的数据集合
	 */
	public Set<Object> getZSet(String key, long startIndex, long endIndex) {
		if (ObjectUtils.isBlank(key)) {
			return new HashSet<Object>();
		}
		Set<Object> set = this.redisTemplate.opsForZSet().range(key, startIndex, endIndex);
		return set;
	}

	/**
	 * @title ZSet->获取所有ZSet数据
	 * @param redis的key
	 * @return 获取到的数据集合
	 */
	public Set<Object> getZSetAll(String key) {
		if (ObjectUtils.isBlank(key)) {
			return new HashSet<Object>();
		}
		Set<Object> set = getZSet(key, 0, -1);
		return set;
	}

	/**
	 * @title ZSet->删除数据
	 * @return 成功返回删除的条数
	 */
	public Long removeZSet(String key, Object[] obj) {
		if (ObjectUtils.isBlank(obj)) {
			return 0L;
		}
		Long rem = this.redisTemplate.opsForZSet().remove(key, obj);
		return ObjectUtils.isBlank(rem) ? 0L : rem;
	}

	/**
	 * @title ZSet->删除数据
	 * @param remove("key", "val1", "val2");
	 * @return 成功返回删除的条数
	 */
	public Long removeZSets(String key, Object... obj) {
		if (ObjectUtils.isBlank(obj)) {
			return 0L;
		}
		return removeZSet(key, obj);
	}

	/******************************* Expire *******************************/

	/**
	 * @title 给指定的缓存数据添加失效时间
	 * @param TimeUnit.DAYS;         天
	 * @param TimeUnit.HOURS;        小时
	 * @param TimeUnit.MINUTES;      分钟
	 * @param TimeUnit.SECONDS;      秒
	 * @param TimeUnit.MILLISECONDS; 毫秒
	 */
	public void setExpire(String key, Long timeout, TimeUnit unit) {
		this.redisTemplate.expire(key, timeout, unit);
	}

	/**
	 * @title 给指定的缓存数据添加失效时间
	 * @param TimeUnit.DAYS;         天
	 * @param TimeUnit.HOURS;        小时
	 * @param TimeUnit.MINUTES;      分钟
	 * @param TimeUnit.SECONDS;      秒
	 * @param TimeUnit.MILLISECONDS; 毫秒
	 */
	public void setTimeout(String key, Long timeout, TimeUnit unit) {
		setExpire(key, timeout, unit);
	}

	/**
	 * @title 获取失效时间
	 * @param redis的key
	 * @return 失效时长
	 */
	public Long getExpire(String key) {
		if (ObjectUtils.isBlank(key)) {
			return 0L;
		}
		Long timeout = this.redisTemplate.getExpire(key);
		return ObjectUtils.isBlank(timeout) ? 0L : timeout;
	}

	/**
	 * @title 获取指定单位的失效时间
	 * @param TimeUnit.DAYS;         天
	 * @param TimeUnit.HOURS;        小时
	 * @param TimeUnit.MINUTES;      分钟
	 * @param TimeUnit.SECONDS;      秒
	 * @param TimeUnit.MILLISECONDS; 毫秒
	 */
	public Long getExpire(String key, TimeUnit unit) {
		if (ObjectUtils.isBlank(key)) {
			return 0L;
		}
		Long timeout = this.redisTemplate.getExpire(key, unit);
		return ObjectUtils.isBlank(timeout) ? 0L : timeout;
	}

	/******************************* END *******************************/

	/**
	 * @title 获取JSON转为对象后的数据
	 */
	@SuppressWarnings("unchecked")
	public <T> T getJsonToObj(String key, Class<T> obj) {
		String jsonStr = ObjectUtils.getStr(this.redisTemplate.opsForValue().get(key));
		if (ObjectUtils.isNotEmpty(jsonStr)) {
			return ObjectUtils.toObj(jsonStr, obj);
		}
		return (T) obj.getClass();
	}

}

对象工具类

import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializeConfig;
import cn.molu.wstm.vo.ResponseVo;

/**
 * 对象工具类封装
 * @Description
 * @author 陌路
 * @date 2022-04-28 
 */
public class ObjectUtils {

	/**
	 * @title 获取字符串
	 * @Desc 为空则返回空字符串
	 */
	public static String getStr(Object obj) {
		if (!isBlank(obj)) {
			return String.valueOf(obj);
		}
		return "";
	}

	/**
	 * @Title 获取对象数据
	 * @Desc 为空则通过反射生成对象
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getObj(Object obj) {
		if (isBlank(obj)) {
			return (T) obj.getClass();
		}
		return (T) obj;
	}

	/**
	 * @param 字符串、对象、数组、集合、基本类型
	 * @title 严格校验,值为""或者null认为是空
	 * @Desc 数组、集合中，若值为（null、""）则认为是空
	 * @return 为空时返回true，否则返回false
	 */
	public static boolean isBlank(Object obj) {
		if (obj == null || "".equals(String.valueOf(obj))) {
			return true;
		}
		if (obj instanceof String) {
			String str = String.valueOf(obj).trim();
			return StringUtils.isBlank(str);
		}
		if (obj instanceof Long || obj instanceof Integer || obj instanceof Double || obj instanceof Short
				|| obj instanceof Float || obj instanceof Boolean) {
			return StringUtils.isBlank(String.valueOf(obj).trim());
		}
		if (obj instanceof Object[]) {
			return checkArr((Object[]) obj);
		}
		if (obj instanceof Collection<?>) {
			return checkCol((Collection<?>) obj);
		}
		if (obj instanceof Map<?, ?>) {
			return checkMap((Map<?, ?>) obj);
		}
		return !org.apache.commons.lang3.ObjectUtils.allNotNull(obj);
	}

	/**
	 * @param 数组校验，为空返回true
	 * @title 严格校验，（null、""）则认为是空
	 * @Desc 校验数组是否为空，若值为（""）也认为是空
	 * @return 为空时返回true，否则返回false
	 */
	public static boolean checkArr(Object[] obj) {
		if (obj == null) {
			return true;
		}
		if (obj.length < 1) {
			return true;
		}
		int i = 0;
		for (Object o : obj) {
			if (StringUtils.isBlank(String.valueOf(o).trim())) {
				++i;
			}
		}
		return i == obj.length ? true : false;
	}

	/**
	 * @title 对象校验，为空返回true
	 * @param 严格校验，（null、""）则认为是空
	 * @Desc 数组、集合的值为（""）时则认为是空
	 * @return 为空时返回true，否则返回false
	 */
	public static boolean isEmpty(Object obj) {
		return isBlank(obj);
	}

	/**
	 * @title 多数据校验，为空返回true
	 * @param （null、""），有一个为空则返回true
	 * @Desc 数组、集合中，若值为（null、""）则认为是空
	 * @return 为空时返回true,否则返回false
	 */
	public static boolean isEmpty(Object... obj) {
		if (obj == null) {
			return true;
		}
		for (Object o : obj) {
			if (isBlank(o)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * @title 对象校验
	 * @return 对象不为空时返回true
	 */
	public static boolean isNotEmpty(Object obj) {
		return !isBlank(obj);
	}

	/**
	 * @title Map集合校验，为空返回true
	 * @return 值为（null、""）返回true
	 */
	public static boolean checkMap(Map<?, ?> obj) {
		if (obj == null || obj.isEmpty() || obj.keySet().size() < 1 || obj.values().size() < 1) {
			return true;
		}
		int i = 0;
		for (Object o : obj.values()) {
			if (obj == null || StringUtils.isBlank(String.valueOf(o).trim())) {
				++i;
			}
		}
		return i == obj.values().size() ? true : false;
	}

	/**
	 * @title 集合校验，为空返回true
	 * @return 值为(null、"")返回true
	 */
	public static boolean checkCol(Collection<?> c) {
		if (c == null || c.isEmpty() || c.size() < 1) {
			return true;
		}
		int i = 0;
		for (Object v : c) {
			if (v == null || StringUtils.isBlank(String.valueOf(v).trim())) {
				++i;
			}
		}
		return i == c.size() ? true : false;
	}

	/**
	 * @title JSON转Map集合
	 */
	private static Map<?, ?> jsonToMap(String jsonStr) {
		if (isBlank(jsonStr)) {
			return new HashMap<String, Object>();
		}
		return JSONObject.parseObject(jsonStr, Map.class);
	}

	/**
	 * @title Map集合转为对象
	 * @param map 集合
	 * @param obj 对象
	 */
	@SuppressWarnings("unchecked")
	public static <T> T mapToObj(Map<String, Object> map, Class<T> obj) {
		if (!isBlank(map)) {
			String jsonString = toJSON(map);
			return JSONObject.parseObject(jsonString, obj);
		}
		return (T) obj.getClass();
	}

	/**
	 * @title JSONString转Object对象
	 */
	@SuppressWarnings("unchecked")
	public static <T> T toObj(String jsonStr, Class<T> obj) {
		if (!isBlank(jsonStr)) {
			return JSONObject.parseObject(jsonStr, obj);
		}
		return (T) obj.getClass();
	}

	/**
	 * @title 对象数据转JSONString数据
	 * @Desc 实现了 SerializeConfig.globalInstance
	 */
	public static String toJSON(Object obj) {
		if (!isBlank(obj)) {
			Object json = JSONObject.toJSON(obj, SerializeConfig.globalInstance);
			return getStr(json);
		}
		return "";
	}

	/**
	 * @param 数据检验，为空则结束执行，并抛出errMsg异常
	 * @title 严格校验，（null、""）则认为是空
	 * @Desc 数组、集合中，若值为（null、""）则认为是空
	 * @return 不为空返回true，为空抛出errMsg异常
	 */
	public static boolean checkNull(HttpServletResponse res, Object params, String errMsg) {
		if (StringUtils.isEmpty(errMsg)) {
			errMsg = ResponseVo.PARAM_ERROR.msg();
		}
		if (isBlank(params)) {
			return true;
		}
		errMsg(res, errMsg);
		throw new NullPointerException(errMsg);
	}

	/**
	 * @param 多参数检验，有一个为空则运行结束，并抛出errMsg异常
	 * @title 严格校验，值为（null、""）则认为是空
	 * @Desc 数组、集合中，若值为（null、""）则认为是空
	 * @return 都不为空返回true，有一个为空则抛出errMsg异常
	 */
	public static boolean checkNull(HttpServletResponse res, String errMsg, Object... params) {
		if (StringUtils.isEmpty(errMsg)) {
			errMsg = ResponseVo.PARAM_ERROR.msg();
		}
		for (Object object : params) {
			if (isBlank(object)) {
				errMsg(res, errMsg);
				throw new NullPointerException(errMsg);
			}
		}
		return true;
	}

	/**
	 * @title 输出错误异常信息
	 * @param res对象，msg异常提示信息
	 */
	public static void errMsg(HttpServletResponse res, String msg) {
		printJsonMsg(res, false, msg, null, 500);
	}

	/**
	 * @Title 输入JSON数据
	 * @param msg提示信息，data数据，code代码
	 */
	public static void printMsg(HttpServletResponse res, String msg, Object data, Integer code) {
		printJsonMsg(res, true, msg, data, code);
	}

	/**
	 * @Title 输出json
	 * @param response
	 * @param flag     状态标示 请求处理成功 或失败
	 * @param msg      该结果的返回提示信息
	 */
	public static void printJsonMsg(HttpServletResponse res, Object flag, String msg, Object data, Integer coed) {
		JSONObject jo = new JSONObject();
		jo.put("flag", flag);
		if (StringUtils.isNotBlank(msg)) {
			jo.put("msg", msg);
		}
		if (data != null) {
			jo.put("data", data);
		}
		if (coed != null) {
			jo.put("coed", coed);
		}
		res.setContentType("text/json;charset=UTF-8");
		try {
			res.getWriter().print(jo);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}