Java&&Redis

pom包引用

    <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
   </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>2.2.6.RELEASE</version>
    </dependency>

代码示例

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName RedisUtil
 * @Description: Redis工具类
 * @Author linkage
 * @Date 2020/4/28  13:45
 * @Version V1.0
 **/
@Component
@Slf4j
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 判断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
     */
    public void del(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 获取数据
     *
     * @param key
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

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

    /**
     * 普通缓存放入,无过期时间
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value) {
        return this.set(key, value, 0);
    }

    /**
     * 递增
     *
     * @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);
    }

    /**
     * 加锁,setIfAbsent 表示key不存在的时候才可以设置成功，存在则设置失败
     *
     * @param key        键
     * @param value      对应的值
     * @param expireTime 过期时间，单位秒
     * @return true 加锁成功，false 加锁失败
     */
    public boolean getLock(String key, String value, int expireTime) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 释放锁，当key对应的value 与存储的值相同时，才可以释放锁
     *
     * @param key   键
     * @param value 对应的值
     * @return true 释放锁成功，false 释放锁失败
     */
    public boolean releaseLock(String key, String value) {
        // 1: 成功，0: 锁不存在，或锁已不归当前key 所有(value不一致）
        Long result = (Long) redisTemplate.execute(new DefaultRedisScript<Long>(
                "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end", Long.class), Arrays.asList(key), value);
        if (result != null && result > 0) {
            return true;
        } else {
            log.error("锁不存在，或锁已不归当前key 所有(value不一致） key:{} value:{}", key, value);
            return false;
        }
    }

    /**
     * 获取匹配的key
     *
     * @param key
     * @return
     */
    public List<String> keys(String key) {
        return new ArrayList<>(redisTemplate.keys(key));
    }

    /**
     * set 缓存
     *
     * @param key   建
     * @param value 值
     * @return true成功 false 失败
     */
    public boolean add(String key, Object value) {
        try {
            Long res = redisTemplate.opsForSet().add(key, value);
            if (res > 0) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获取set值
     *
     * @param key
     * @return
     */
    public Object getSet(String key) {
        try {
            Object obj = redisTemplate.opsForSet().members(key);
            return obj;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * remove 移除set中的值
     *
     * @param key
     * @param value 要移除的值
     * @return
     */
    public boolean remove(String key, Object value) {
        try {
            Long res = redisTemplate.opsForSet().remove(key, value);
            if (res > 0) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * zset 添加
     *
     * @param key
     * @param value
     */
    public void addZSet(String key, Serializable value, double score) {
        if (value != null) {
            this.redisTemplate.opsForZSet().add(key, value, score);
        }
    }

    /**
     * zset 删除
     *
     * @param key
     * @param value
     */
    public void removeZSet(String key, Serializable value) {
        this.redisTemplate.opsForZSet().remove(key, value);
    }

    /**
     * 
     * 获取zset所有值
     *
     * @param key
     * @return
     */
    public Set<Serializable> getZSetAll(String key) {
        return redisTemplate.opsForZSet().reverseRange(key, 0, -1);
    }


    /**
     * 设置单个Hash值
     *
     * @param key
     * @param field
     * @param value
     */
    public void addHash(String key, String field, Object value) {
        if (field != null) {
            this.redisTemplate.opsForHash().put(key, field, value);
        }
    }

    /**
     * 设置HASH缓存 全量
     *
     * @param key
     * @param m
     */
    public void addHashAll(String key, Map m) {
        if (m != null) {
            this.redisTemplate.opsForHash().putAll(key, m);
        }
    }


    /**
     * 获取全部HASH,key-value缓存值
     *
     * @param key
     * @return
     */
    public Map getHashAllMap(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取全部HASH,value缓存值
     *
     * @param key
     * @return
     */
    public List getHashAllValue(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    /**
     * 获取指定field 值
     * @param key
     * @param list field列表
     * @return
     */
    public List getHashByHashKey(String key, List<String> list) {
        return redisTemplate.opsForHash().multiGet(key, list);
    }

    /**
     * 删除hash
     *
     * @param key
     * @param list
     * @return
     */
    public Boolean removeHash(String key, List<String> list) {
        if(list!=null && list.size()>0) {
            Long res = redisTemplate.opsForHash().delete(key, list.toArray(new String[list.size()]));
            return res >= 0;
        }
        return false;
    }
}