redis 工具类

maven依赖

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

工具类代码

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

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

@Component
public class RedisUtils implements InitializingBean {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);

//    private static final String LOCK_SCRIPT = "local a = redis.call('setnx',KEYS[1],ARGV[1]); if(a==1) then redis.call('Expire',KEYS[1],ARGV[2]); end return a;";

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

//    public Object call(String script, List<String> keys, String...args) {
//        logger.info("Redis call script:{},value:{}", script, args);
//        return redisTemplate.execute(new DefaultRedisScript<>(script), keys, (Object[])args);
//    }

    public long ssize(String key) {
        logger.debug("Redis randomMembers key:{}", key);
        return redisTemplate.opsForSet().size(key);
    }

    public Set<String> distinctRandomMembers(String key, long size) {
        logger.debug("Redis randomMembers key:{},size:{}", key, size);
        return redisTemplate.opsForSet().distinctRandomMembers(key, size);
    }

    public void sadd(String key, String value) {
        logger.debug("Redis sadd key:{},value:{}", key, value);
        redisTemplate.opsForSet().add(key, value);
    }

    public boolean sismember(String key, String value) {
        logger.debug("Redis sismember key:{},value:{}", key, value);
        Boolean isMember = redisTemplate.opsForSet().isMember(key, value);
        return isMember != null && isMember;
    }

    public long srem(String key, String... value) {
        logger.debug("Redis srem key:{},value:{}", key, value);
        final Long remove = redisTemplate.opsForSet().remove(key, (Object[]) value);
        return remove == null ? 0 : remove;
    }

    public Set<String> smembers(String key) {
        logger.debug("Redis smembers key:{}", key);
        return redisTemplate.opsForSet().members(key);
    }

    public void set(String key, String value) {
        logger.debug("Redis set key:{},value:{}", key, value);
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * hash 类型key 自增长
     */
    public long hIncrBy(String key, String value, long step){
        logger.debug("Redis set key:{},value:{},step:{}", key, value, step);
        return redisTemplate.opsForHash().increment(key,value, step);
    }

    public void hdel(String key, String value) {
        logger.debug("Redis hdel key:{},value:{}", key, value);
        redisTemplate.opsForHash().delete(key, value);
    }

    public Long increment(String key, long value){
        logger.debug("Redis set key:{},value:{}", key, value);
        return redisTemplate.opsForValue().increment(key,value);
    }

    public Double increment(String key, double value){
        logger.debug("Redis set key:{},value:{}", key, value);
        return redisTemplate.opsForValue().increment(key,value);
    }

    public void set(String key, String value, long time, TimeUnit timeUnit) {
        logger.debug("Redis set key:{},value:{},time:{},timeUnit:{}", key, value, time, timeUnit);
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
    }

    public boolean del(String key) {
        logger.debug("Redis del key:{}", key);
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    /**
     * 保存 若key已存在返回false,反之返回true
     */
    public boolean setIfAbsent(String key, String value) {
        logger.debug("Redis setIfAbsent key:{},value:{}", key, value);
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value);
        return result != null && result;
    }

//    public boolean setIfAbsentWithScript(String key, String value, long time) {
//        logger.debug("Redis setIfAbsent key:{},value:{},time:{},timeUnit:{}", key, value, time);
//        return redisTemplate.execute(new DefaultRedisScript<>(LOCK_SCRIPT), Arrays.asList(new String[]{key}), new Object[]{value,time});
//    }

    /**
     * 保存 若key已存在返回false,反之返回true 同时设置有效时间
     */
    public boolean setIfAbsent(String key, String value, long time, TimeUnit timeUnit) {

        logger.debug("Redis setIfAbsent key:{},value:{},time:{},timeUnit:{}", key, value, time, timeUnit);
        try {
            return setIfAbsent(key, value);
        }finally {
            redisTemplate.boundValueOps(key).expire(time, timeUnit);
        }
    }

    public boolean setIfAbsent(String key, String value, Date date) {

        logger.debug("Redis setIfAbsent key:{},value:{},date:{},", key, value, date);
        try {
            return setIfAbsent(key, value);
        }finally {
            redisTemplate.boundValueOps(key).expireAt(date);
        }
    }

    public String get(String key) {
        logger.debug("Redis get key:{}", key);
        return redisTemplate.opsForValue().get(key);
    }

    public boolean hasKey(String key) {
        logger.debug("Redis hasKey key:{}", key);
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    public Set<Object> hkeys(String key){
        logger.debug("Redis hash hkeys {}", key);
        return redisTemplate.boundHashOps(key).keys();
    }

    public Set<String> getkeyS(String key) {
        logger.debug("Redis get key:{}", key);
        return redisTemplate.keys(key);
    }

    public void convertAndSend(String channel, Object msg) {
        logger.debug("Redis convertAndSend channel:{},msg:{}", channel, msg);
        redisTemplate.convertAndSend(channel, msg);
    }

    public boolean hexists(String key,String field) {
        logger.debug("Redis hash hasKey key:{},field:{}", key, field);
        return redisTemplate.opsForHash().hasKey(key, field);
    }

    public void hset(String key,String field, String value) {
        logger.debug("Redis hash set key:{},field:{}", key, field);
        redisTemplate.opsForHash().put(key, field, value);
    }

    public void hset(String key,String field, String value, long time, TimeUnit timeUnit) {
        logger.debug("Redis setIfAbsent key:{},value:{},time:{},timeUnit:{}", key, value, time, timeUnit);
        try {
            redisTemplate.opsForHash().put(key, field, value);
        }finally {
            redisTemplate.boundValueOps(key).expire(time, timeUnit);
        }
    }

    public Object hget(String key,String field) {
        logger.debug("Redis hash get key:{},field:{}", key, field);
        return redisTemplate.opsForHash().get(key, field);
    }

    public List<Object> hgets(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    public Map<Object, Object> hgetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    public Boolean zsetAdd(String key,String value,double score){
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    public Double zsetIncrementScore(String key, String value, double delta){
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    public Set<String> zSetRangeByScore(String key, double start, double end){
        return redisTemplate.opsForZSet().rangeByScore(key, start, end);
    }

    public Set<ZSetOperations.TypedTuple<String>> zSetRangeWithScores(String key, long start, long end){
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    public Set<String> zSetReverseRange(String key, long start, long end){
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    public Long zSetSize(String key){
        return redisTemplate.opsForZSet().size(key);
    }

    public Long zSetCount(String key, double min, double max){
        return redisTemplate.opsForZSet().count(key, min, max);
    }

    public Long zSetRemoveRangeByScore(String key, double min, double max){
        return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    public Boolean expire(String key, long time, TimeUnit timeUnit) {
        return redisTemplate.boundValueOps(key).expire(time, timeUnit);
    }

    /**
     * 从redis中获取key对应的过期时间;
     * 如果该值有过期时间，就返回相应的过期时间;
     * 如果该值没有设置过期时间，就返回-1;
     * 如果没有该值，就返回-2;
     * 单位 ：秒（s）
     */
    public long getExpire(String key) {
        return redisTemplate.opsForValue().getOperations().getExpire(key);
    }

    public Boolean expireAt(String key, Date date) {
        return redisTemplate.boundValueOps(key).expireAt(date);
    }

    public Long increment(String key, long value, long time, TimeUnit timeUnit) {
        try {
            return increment(key, value);
        } finally {
            expire(key, time, timeUnit);
        }
    }

    public Boolean zsetAdd(String key,String value,double score, long time, TimeUnit timeUnit) {
        try {
            return zsetAdd(key, value, score);
        } finally {
            expire(key, time, timeUnit);
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        redisTemplate.opsForSet().size("kf:temst");
    }
}