通用缓存工具类

package com.juzi.sms.service;

import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

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

/**
 * @author wangzw
 * @version 1.0
 * @date 2018/3/15 11:31
 */
@Component
@Slf4j
public class RedisService {
    @Autowired
    private RedisTemplate       redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public boolean existsKey(String redisKey) {
        boolean result = redisTemplate.hasKey(redisKey);
        log.info("class:[{}],method:[{}],key:[{}],val:[{}]", this.getClass().getName(), "existsKey", redisKey, result);
        return result;
    }

    /**
     * 设置 key 的值为 value
     * 如果key不存在添加key 保存值为value
     * 如果key存在则对value进行覆盖
     *
     * @param key
     * @param value
     */
    public boolean setForeverData(String key, Object value) {
        try {
            ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(key, value);
            log.info("method:[{}],key:[{}],val:[{}]", "setForeverData", key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 设置 key 的值为 value
     * 其它规则与 set(K key, V value)一样
     *
     * @param key        不能为空
     * @param value      设置的值
     * @param expireTime 设置过期的时间-秒
     * @author wangzw
     * @version 1.0
     * @date 2018/3/15 13:54
     */
    public boolean setTimeData(String key, Object value, int expireTime) {
        try {
            ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            log.info("method:[{}],key:[{}],val:[{}],expireTime:[{}]S", "setTimeData", key, value, expireTime);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public boolean setDaysData(String key, Object value, int expireTime) {
        try {
            ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.DAYS);
            log.info("method:[{}],key:[{}],val:[{}],expireTime:[{}]S", "setDaysData", key, value, expireTime);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public Long incrKey(String key) {
        ValueOperations operations = redisTemplate.opsForValue();
        Long increment = operations.increment(key, 1);
        log.info("method:[{}],key:[{}],val:[{}]", "incrKey", key, increment);
        return increment;
    }

    /**
     * 得到一段时间内key的计数
     *
     * @param key
     * @param expireTime
     * @author wangzw
     * @version 1.0
     * @date 2018/4/11 14:09
     */
    public Long incrKey(String key, long expireTime) {
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        Long increment = operations.increment(key, 1);
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        log.info("method:[{}],key:[{}],val:[{}],expireTime:[{}]S", "incrKey", key, increment, expireTime);
        return increment;
    }

    public Object getObjectByKey(String redisKey) {
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        Object redisVal = operations.get(redisKey);
        log.info("method:[{}],key:[{}],val:[{}]", "getObjectByKey", redisKey, redisVal);
        return redisVal;
    }

    /**
     * 获取incr后的key的value
     *
     * @param redisKey
     * @author wangzw
     * @version 1.0
     * @date 2018/4/27 10:13
     */
    public String boundValue(String redisKey) {
        String boundVal = redisTemplate.boundValueOps(redisKey).get(0, -1);
        log.info("method:[{}],key:[{}],val:[{}]", "boundValue", redisKey, boundVal);
        return boundVal;
    }

    /**
     * 存储set格式数据
     *
     * @param redisKey
     * @return
     */
    public boolean setOpsForSet(String redisKey, Object values) {
        try {
            SetOperations opsForSet = redisTemplate.opsForSet();
            opsForSet.add(redisKey, values);
            log.info("method:[{}],key:[{}],values:[{}]", "setOpsForSet", redisKey, values);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public boolean setOpsForSet(String redisKey, Set<String> value, Integer expDays) {
        try {
            String[] sValue = value.toArray(new String[value.size()]);
            SetOperations opsForSet = redisTemplate.opsForSet();
            opsForSet.add(redisKey, sValue);
            if (!StringUtils.isEmpty(expDays)) {
                redisTemplate.expire(redisKey, expDays, TimeUnit.DAYS);
            }
            log.info("method:[{}],key:[{}],valSize:[{}]", "setOpsForSet", redisKey, value.size());
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public Object getSetByKey(String redisKey) {
        SetOperations setOperations = redisTemplate.opsForSet();
        Set members = setOperations.members(redisKey);
        log.info("method:[{}],key:[{}],valSize:[{}]", "getSetByKey", redisKey, members.size());
        return members;
    }

    public Boolean isMemberSetOpt(String redisKey, String subkey) {
        SetOperations setOperations = redisTemplate.opsForSet();
        Boolean member = setOperations.isMember(redisKey, subkey);
        log.info("method:[{}],key:[{}],isMember:[{}]", "isMember", redisKey, member);
        return member;
    }

    public void removeSetOpt(String redisKey, String subkey) {
        SetOperations setOperations = redisTemplate.opsForSet();
        Long remove = setOperations.remove(redisKey, subkey);
        log.info("method:[{}],key:[{}],subkey[{}],removeSetOpt:[{}]", "removeSetOpt", redisKey, subkey, remove);
    }

    /**
     * hash 操作
     */
    public boolean setOpsForHash(String redisKey, String subKey, String value) {
        try {
            HashOperations hashOperations = redisTemplate.opsForHash();

            hashOperations.put(redisKey, subKey, value);
            log.info("method:[{}],key:[{}],subkey[{}],value[{}]", "setOpsForHash", redisKey, subKey, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public String getHashValue(String redisKey, String subKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        Object o = hashOperations.get(redisKey, subKey);
        log.info("method:[{}],key:[{}],subkey[{}],getHashValue:[{}]", "getHashValue", redisKey, subKey, o);
        return StringUtils.isEmpty(o) ? null : String.valueOf(o);
    }

    public Long getLongHashValue(String redisKey, String subKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        Object o = hashOperations.get(redisKey, subKey);
        log.info("method:[{}],key:[{}],subkey[{}],getLongHashValue:[{}]", "getLongHashValue", redisKey, subKey, o);
        return StringUtils.isEmpty(o) ? 0 : Long.valueOf(String.valueOf(o));
    }

    public void removeOpsForHash(String redisKey, String subKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(redisKey, subKey);
        log.info("method:[{}],key:[{}],subkey[{}]", "removeOpsForHash", redisKey, subKey);
    }

    public boolean hasHashKey(String redisKey, String subKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        Boolean exit = hashOperations.hasKey(redisKey, subKey);
        log.info("method:[{}],key:[{}],subkey[{}],exit:[{}]", "hasHashKey", redisKey, subKey, exit);
        return exit;
    }

    public Map getAllHash(String redisKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        return hashOperations.entries(redisKey);
    }

    /**
     * incr 自增
     *
     * @param key
     */
    public Long incr(String key, long num) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        return valueOperations.increment(key, num);
    }

    public Long decr(String key, long num) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        return valueOperations.increment(key, -num);
    }

    public Long hashIncr(String redisKey, String subKey, long num) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        return hashOperations.increment(redisKey, subKey, num);
    }

    public Long hashDecr(String redisKey, String subKey, long num) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        return hashOperations.increment(redisKey, subKey, -num);
    }

    public boolean deleteByKey(String... redisKey) {
        boolean result = false;
        try {
            for (String key : redisKey) {
                redisTemplate.delete(key);
            }
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("class:[{}],method:[{}],key:[{}],val:[{}]", this.getClass().getName(), "deleteByKey", redisKey, result);
        return result;
    }

    private boolean exists(final String redisKey) {
        return redisTemplate.hasKey(redisKey);
    }

    /**
     * 根据key 存了个List<String>数组，
     * @param redisKey  键
     * @param value  数组List
     * @param expDays 设置过期的天数
     */
    public boolean setOpsForList(String redisKey, List<String> value, Integer expDays) {
        try {
            redisTemplate.opsForList().rightPush(redisKey,value);
            if (!StringUtils.isEmpty(expDays)) {
                redisTemplate.expire(redisKey, expDays, TimeUnit.DAYS);
            }
            log.info("method:[{}],key:[{}],valSize:[{}]", "setOpsForList", redisKey, value.size());
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 根据key 取List<String>数组
     * @param redisKey  键
     */
    public <T> List<T> getListValue(String redisKey) {
        ListOperations listOperations = redisTemplate.opsForList();
        List<T> list = (List<T>)listOperations.rightPop(redisKey);
        log.info("redisKey:[{}],value:[{}]", "getHashValue", redisKey, list);
        return list == null || list.size() <= 0 ? null : list;
    }



}