1、修改redis工具类

core/src/main/java/com/ctsi/utils/RedisUtil.java

@@ -2,134 +2,73 @@ package com.ctsi.utils;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.data.redis.core.*;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Component;
-import org.springframework.util.CollectionUtils;
 
 import javax.annotation.Resource;
-import java.io.Serializable;
-import java.util.List;
-import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
-
-/**
- * redis工具类
- *
- * @author lym
- */
-@Component("redisUtil")
-public class RedisUtil {
+@Component
+public final class RedisUtil {
 
     @Resource
-    private RedisTemplate redisTemplate;
-
-    private static final double size = Math.pow(2, 32);
+    private RedisTemplate<String, Object> redisTemplate;
 
     private static final Logger log = LoggerFactory.getLogger(RedisUtil.class);
 
-
     /**
-     * 写入缓存
+     * 普通缓存获取
      *
-     * @param offset 位 8Bit=1Byte
-     * @ return
+     * @param key 键
+     * @return 值
      */
-    public boolean setBit(String key, long offset, boolean isShow) {
-        boolean result = false;
-        try {
-            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
-            operations.setBit(key, offset, isShow);
-            result = true;
-        } catch (Exception e) {
-            log.error(e.getMessage());
-        }
-        return result;
+    public Object get(String key) {
+        return key == null ? null : redisTemplate.opsForValue().get(key);
     }
 
     /**
-     * 写入缓存
+     * 普通缓存放入并设置时间
      *
-     * @param offset
-     * @ return
-     */
-    public boolean getBit(String key, long offset) {
-        boolean result = false;
-        try {
-            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
-            result = operations.getBit(key, offset);
-        } catch (Exception e) {
-            log.error(e.getMessage());
-        }
-        return result;
-    }
-
-
-    /**
-     * 写入缓存
-     *
-     * @param value
-     * @ return
+     * @param key   键
+     * @param value 值
+     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
+     * @return true成功 false 失败
      */
-    public boolean set(final String key, Object value) {
-        boolean result = false;
+    public boolean set(String key, Object value, long time) {
         try {
-            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
-            operations.set(key, value);
-            result = true;
+            if (time > 0) {
+                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
+            } else {
+                set(key, value);
+            }
+            return true;
         } catch (Exception e) {
             log.error(e.getMessage());
+            return false;
         }
-        return result;
     }
 
     /**
-     * 获取失效时间
+     * 普通缓存放入
      *
-     * @param key
-     *            键
-     * @ return 失效时间（秒）
+     * @param key   键
+     * @param value 值
+     * @return true成功 false失败
      */
-    public long getExpire(String key) {
-        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
-    }
 
-    /**
-     * 写入缓存设置时效时间
-     *
-     * @param key
-     * @param value
-     * @ return
-     */
-    public boolean set(final String key, Object value, Long expireTime) {
-        boolean result = false;
+    public boolean set(String key, Object value) {
         try {
-            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
-            operations.set(key, value);
-            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
-            result = true;
+            redisTemplate.opsForValue().set(key, value);
+            return true;
         } catch (Exception e) {
             log.error(e.getMessage());
-        }
-        return result;
-    }
-
-    /**
-     * 批量删除对应的value
-     *
-     * @param keys
-     */
-    public void remove(final String... keys) {
-        for (String key : keys) {
-            remove(key);
+            return false;
         }
     }
 
-
     /**
      * 删除对应的value
      *
-     * @param key
      */
     public void remove(final String key) {
         if (exists(key)) {
@@ -140,204 +79,11 @@ public class RedisUtil {
     /**
      * 判断缓存中是否有对应的value
      *
-     * @param key
-     * @ return
      */
     public boolean exists(final String key) {
-        return redisTemplate.hasKey(key);
-    }
-
-    /**
-     * 读取缓存
-     *
-     * @param key
-     * @ return
-     */
-    public Object get(final String key) {
-        Object result = null;
-        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
-        result = operations.get(key);
-        return result;
-    }
-
-    /**
-     * 哈希 添加
-     *
-     */
-    public void hmSet(String key, Object hashKey, Object value) {
-        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
-        hash.put(key, hashKey, value);
-    }
-
-    /**
-     * 哈希获取数据
-     *
-     * @param hashKey
-     * @ return
-     */
-    public Object hmGet(String key, Object hashKey) {
-        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
-        return hash.get(key, hashKey);
-    }
-
-    /**
-     * 列表添加
-     *
-     * @param k
-     * @param v
-     */
-    public void lPush(String k, Object v) {
-        ListOperations<String, Object> list = redisTemplate.opsForList();
-        list.rightPush(k, v);
-    }
-
-    /**
-     * 列表获取
-     *
-     * @param k
-     * @param l
-     * @param l1
-     * @ return
-     */
-    public List<Object> lRange(String k, long l, long l1) {
-        ListOperations<String, Object> list = redisTemplate.opsForList();
-        return list.range(k, l, l1);
-    }
-
-    /**
-     * 集合添加
-     *
-     * @param key
-     * @param value
-     */
-    public void add(String key, Object value) {
-        SetOperations<String, Object> set = redisTemplate.opsForSet();
-        set.add(key, value);
-    }
-
-    /**
-     * 集合获取
-     *
-     * @param key
-     * @ return
-     */
-    public Set<Object> setMembers(String key) {
-        SetOperations<String, Object> set = redisTemplate.opsForSet();
-        return set.members(key);
-    }
-
-    /**
-     * 有序集合添加
-     *
-     */
-    public void zAdd(String key, Object value, double scoure) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        zset.add(key, value, scoure);
-    }
-
-    /**
-     * 有序集合获取
-     *
-     * @param scoure1
-     * @ return
-     */
-    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        redisTemplate.opsForValue();
-        return zset.rangeByScore(key, scoure, scoure1);
-    }
-
-
-    //第一次加载的时候将数据加载到redis中
-    public void saveDataToRedis(String name) {
-        long indexLong = (long) Math.abs(name.hashCode() % size);
-        boolean availableUsers = setBit("availableUsers", indexLong, true);
-    }
-
-    //第一次加载的时候将数据加载到redis中
-    public boolean getDataToRedis(String name) {
-
-        long indexLong = (long) Math.abs(name.hashCode() % size);
-        return getBit("availableUsers", indexLong);
-    }
-
-    /**
-     * 有序集合获取排名
-     *
-     * @param key   集合名称
-     * @param value 值
-     */
-    public Long zRank(String key, Object value) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        return zset.rank(key, value);
-    }
-
-
-    /**
-     * 有序集合获取排名
-     *
-     * @param key
-     */
-    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start, long end) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key, start, end);
-        return ret;
-    }
-
-    /**
-     * 有序集合添加
-     *
-     */
-    public Double zSetScore(String key, Object value) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        return zset.score(key, value);
-    }
-
-
-    /**
-     * 有序集合添加分数
-     *
-     */
-    public void incrementScore(String key, Object value, double scoure) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        zset.incrementScore(key, value, scoure);
-    }
-
-
-    /**
-     * 有序集合获取排名
-     *
-     */
-    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key, start, end);
-        return ret;
-    }
-
-    /**
-     * 有序集合获取排名
-     *
-     */
-    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
-        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
-        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
-        return ret;
-    }
-
-    public Long delete(String... key) {
-        if (key != null && key.length > 0) {
-            if (key.length == 1) {
-                if(redisTemplate.delete(key[0])) {
-                    return Long.valueOf(1);
-                }else {
-                    return Long.valueOf(0);
-                }
-            } else {
-                return redisTemplate.delete(CollectionUtils.arrayToList(key));
-            }
-        }
-        return Long.valueOf(0);
+        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
     }
 
 }
 
+