java Redis工具类 RedisUtils

package com.wqh.fsrm.framework.redis;

import com.wqh.fsrm.common.util.UUIDUtils;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate;


    /**
     * redis 存值
     * @param key
     * @param value
     */
    public void set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * redis 存值
     * @param key
     * @param value
     * @return
     */
    public void set(String key,Object value,long time){
        try {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * redis 取值
     * @param key
     * @return
     */
    public Object get(String key){
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 根据key 删除redis 中的key和value
     * @param key 可以传一个值 或多个
     */
    public void delete(String key){
        try{
            redisTemplate.delete(key);
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 根据key 删除redis 中的key和value
     * @param key 可以传一个值 或多个
     */
    public void delete(String ... key){
        try{
            if(key!=null&&key.length>0){
                if(key.length==1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 设置过期时间
     * @param key
     * @param time
     */
    public void setExpire(String key,long time){
        try {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置过期时间
     * @param key
     */
    public void setExpire(String key){
        try {
            redisTemplate.expire(key, 60*60, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 根据key 获取过期时间
     * @param key
     * @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 键
     * @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);
    }

    /**
     * 锁住某个key值，需要解锁时删除即可
     *
     * @param key
     * @param value
     * @return
     */
    public boolean getLock(String key, String value,Long expireSecond) {
        try {
            return (Boolean) redisTemplate.execute((RedisCallback<Object>) connection -> {
                byte[] seriaKey = redisTemplate.getStringSerializer().serialize(key);
                Boolean resultFlag = connection.setNX(seriaKey, value.getBytes());
                if (resultFlag) {
                    connection.expire(seriaKey, expireSecond);
                }
                return resultFlag;
            });
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 锁住某个key值，需要解锁时删除即可
     *
     * @param key
     * @return
     */
    public boolean releaseLock(String key) {
        try {
            return (Boolean) redisTemplate.execute((RedisCallback<Object>) connection -> {
                byte[] seriaKey = redisTemplate.getStringSerializer().serialize(key);
                connection.del(seriaKey);
                return true;
            });
        } catch (Exception e) {
            return false;
        }

    }


    /**
     * 通过redisTemplate 加锁
     * @param lockKey
     */
    public void redisTemplateLock(String lockKey){
        String clientId = UUID.randomUUID().toString();
        Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey,clientId,10,TimeUnit.SECONDS);
        if(!result){
            return;
        }
        try {
            //业务逻辑

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(clientId.equals(redisTemplate.opsForValue().get(lockKey))){
                //释放锁
                redisTemplate.delete(lockKey);
            }
        }
    }


    /**
     * 通过stringRedisTemplate 加锁
     * @param lockKey
     */
    public void stringRedisTemplateLock(String lockKey){
        String clientId = UUID.randomUUID().toString();
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey,clientId,10, TimeUnit.SECONDS);
        if(!result){
            return;
        }
        try {
            //业务逻辑

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
                //释放锁
                stringRedisTemplate.delete(lockKey);
            }
        }
    }

    /**
     * 加锁方式
     */
    public void addLocked(){
        String clientId = UUID.randomUUID().toString();
        //加锁防止短时间内重复操作,造成金额问题
        String lockKey = "lock_" + UUIDUtils.getUUID();
        boolean lockStatus = getLock(lockKey, "locked",10L);
        if (!lockStatus) {
            //业务逻辑
        }
        try {
            //业务逻辑
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (lockStatus) {
                releaseLock(lockKey);
            }
        }
    }
}