Redis工具类：RedisTemplate

拼搏现实的明天。 2023-01-22 10:54 25阅读 0赞

## Maven依赖 ##

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.10.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.10.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.10.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

## 第二步：创建JSON工具类 ##

public class JsonUtil { 
        private static ObjectMapper objectMapper = new ObjectMapper();
    
        public static String convertObj2String(Object object) { 
            String s = null;
            try { 
                s = objectMapper.writeValueAsString(object);
            } catch (JsonProcessingException e) { 
                e.printStackTrace();
            }
            return s;
        }
    
        public static <T> T convertString2Obj(String s, Class<T> clazz) { 
            T t = null;
            try { 
                t = objectMapper.readValue(s, clazz);
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return t;
        }
    }

## 第三步：Redis工具类： ##

@Component
    public final class RedisUtil<E> { 
    
        @Resource
        private RedisTemplate<String, E> redisTemplate;
    
        /** * 一周 */
        private static final long WEEK_SECONDS = 7 * 24 * 60 * 60;
    
        // =============================common============================
    
        /** * 列举出所有的key的集合 * * @return */
        public Set<String> keys() { 
            try { 
                Set<String> keys = redisTemplate.keys("*");
                return keys;
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 指定缓存失效时间 * * @param key 键 * @param time 时间(秒) * @return */
        public boolean expire(String key, long time) { 
            try { 
                if (time > 0) { 
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 根据key 获取过期时间 * * @param key 键 不能为null * @return 时间(秒) 返回代表为永久有效 */
        public long getExpire(String key) { 
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /** * 判断key是否存在 * * @param key 键 * @return true 存在 false不存在 */
        public boolean exists(String key) { 
            try { 
                return redisTemplate.hasKey(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 删除缓存 * * @param key 可以传一个值 或多个 */
        @SuppressWarnings("unchecked")
        public void del(String... key) { 
            if (key != null && key.length > 0) { 
                if (key.length == 1) { 
                    redisTemplate.delete(key[0]);
                } else { 
                    redisTemplate.delete(Arrays.stream(key).collect(Collectors.toList()));
                }
            }
        }
    
        // ============================String=============================
    
        /** * 普通缓存放入，使用系统默认的过期时间 * * @param key 键 * @param value 值 * @return true成功 false失败 */
        public boolean set(String key, E value) { 
            try { 
                redisTemplate.opsForValue().set(key, value, WEEK_SECONDS, TimeUnit.SECONDS);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 普通缓存放入并设置时间 * * @param key 键 * @param value 值 * @param expireTime 时间(秒) time要大于 如果time小于等于 将设置无限期 * @return true成功 false 失败 */
        public boolean set(String key, E value, long expireTime) { 
            try { 
                if (expireTime > 0) { 
                    redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
                } else { 
                    set(key, value);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        public boolean multiSet(Map<String, E> map) { 
            try { 
                redisTemplate.opsForValue().multiSet(map);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 普通缓存获取 * * @param key 键 * @return 值 */
        public E get(String key) { 
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /** * 获取与 key 对应的对象 * * @param key * @param clazz 目标对象类型 * @param <E> * @return */
        public <E> E get(String key, Class<E> clazz) { 
            String s = get(key).toString();
            if (s == null) { 
                return null;
            }
            return JsonUtil.string2Obj(s, clazz);
        }
    
    
        /** * 递增 * * @param key 键 * @param delta 要增加几(大于) * @return */
        public long incr(String key, long delta) { 
            if (delta < 0) { 
                throw new RuntimeException("递增因子必须大于");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /** * 递减 * * @param key 键 * @param delta 要减少几(小于) * @return */
        public long decr(String key, long delta) { 
            if (delta < 0) { 
                throw new RuntimeException("递减因子必须大于");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        // ================================Map/hash=================================
        //注：Redis的hash的entryKey的类型必须为String类型
        /** * 向一张hash表中放入数据,如果不存在将创建 * * @param key 键 * @param entryKey 项 * @param entryValue 值 * @return true 成功 false失败 */
        public boolean hset(String key, String entryKey, E entryValue) { 
            try { 
                redisTemplate.opsForHash().put(key, entryKey, entryValue);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 向一张hash表中放入数据,如果不存在将创建 * * @param key 键 * @param entryKey 项 * @param entryValue 值 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 * @return true 成功 false失败 */
        public boolean hset(String key, String entryKey, E entryValue, long time) { 
            try { 
                redisTemplate.opsForHash().put(key, entryKey, entryValue);
                if (time > 0) { 
                    expire(key, time);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * HashSet * * @param key 键 * @param map 对应多个键值 * @return true 成功 false 失败 */
        public boolean hmset(String key, Map<String, E> map) { 
            try { 
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * HashSet 并设置时间 * * @param key 键 * @param map 对应多个键值 * @param time 时间(秒) * @return true成功 false失败 */
        public boolean hmset(String key, Map<String, E> map, long time) { 
            try { 
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) { 
                    expire(key, time);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * HashGet * * @param key 键 不能为null * @param item 项 不能为null * @return 值 */
        public E hget(String key, String item) { 
            return (E) redisTemplate.opsForHash().get(key, item);
        }
    
        /** * 获取hashKey对应的所有键值 * * @param key 键 * @return 对应的多个键值 */
        public <V> Map<String, V> hmget(String key) { 
            HashOperations<String, String, V> hashOperations = redisTemplate.opsForHash();
            return hashOperations.entries(key);
        }
    
        /** * 删除hash表中的值 * * @param key 键 不能为null * @param entryKey 项 可以使多个 不能为null */
        public   void hdel(String key, String... entryKey) { 
            redisTemplate.opsForHash().delete(key, entryKey);
        }
    
        /** * 判断hash表中是否有该项的值 * * @param key 键 不能为null * @param entryKey 项 不能为null * @return true 存在 false不存在 */
        public  boolean hHasKey(String key, String entryKey) { 
            return redisTemplate.opsForHash().hasKey(key, entryKey);
        }
    
        /** * hash递增 如果不存在,就会创建一个 并把新增后的值返回 * * @param key 键 * @param entryKey 项 * @param by 要增加几(大于) * @return */
        public double hincr(String key, String entryKey, double by) { 
            return redisTemplate.opsForHash().increment(key, entryKey, by);
        }
    
        /** * hash递减 * * @param key 键 * @param entryKey 项 * @param by 要减少记(小于) * @return */
        public double hdecr(String key, String entryKey, double by) { 
            return redisTemplate.opsForHash().increment(key, entryKey, -by);
        }
    
        // ============================set=============================
    
        /** * 将数据放入set缓存 * * @param key 键 * @param values 值 可以是多个 * @return 成功个数 */
        public long sSet(String key, E... values) { 
            try { 
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 将set数据放入缓存 * * @param key 键 * @param time 时间(秒) * @param values 值 可以是多个 * @return 成功个数 */
        public long sSetWithExpire(String key, long time, E... values) { 
            try { 
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0) { 
                    expire(key, time);
                }
                return count;
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 根据key获取Set中的所有值 * * @param key 键 * @return */
        public Set<E> sGet(String key) { 
            try { 
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 根据value从一个set中查询,是否存在 * * @param key 键 * @param value 值 * @return true 存在 false不存在 */
        public boolean sHasKey(String key, E value) { 
            try { 
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 获取set缓存的长度 * * @param key 键 * @return */
        public long sGetSetSize(String key) { 
            try { 
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 移除值为value的 * * @param key 键 * @param values 值 可以是多个 * @return 移除的个数 */
        public long setRemove(String key, E... values) { 
            try { 
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        // ===============================list=================================
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, E value) { 
            try { 
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
        public boolean lSet(String key, E value, long time) { 
            try { 
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) { 
                    expire(key, time);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @return */
        public boolean lSets(String key, List<E> value) { 
            try { 
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
        public boolean lSets(String key, List<E> value, long time) { 
            try { 
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) { 
                    expire(key, time);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 获取list缓存的内容 * * @param key 键 * @param start 开始 * @param end 结束 到 -代表所有值 * @return */
        public List<E> lGet(String key, long start, long end) { 
            try { 
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 获取list缓存的长度 * * @param key 键 * @return */
        public long lGetListSize(String key) { 
            try { 
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 通过索引 获取list中的值 * * @param key 键 * @param index 索引 index>=时， 表头， 第二个元素，依次类推；index<时，-，表尾，-倒数第二个元素，依次类推 * @return */
        public Object lGetIndex(String key, long index) { 
            try { 
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 根据索引修改list中的某条数据 * * @param key 键 * @param index 索引 * @param value 值 * @return */
        public boolean lUpdateIndex(String key, long index, E value) { 
            try { 
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 移除N个值为value * * @param key 键 * @param count 移除多少个 * @param value 值 * @return 移除的个数 */
        public long lRemove(String key, long count, E value) { 
            try { 
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    }

## RedisUtil测试 ##

@SpringBootTest
    class RedisUtilTest { 
    
        @Resource
        private RedisUtil<Dept> redisUtil;
    
        @Test
        public void fun() { 
            System.out.println(redisUtil);
        }
    
        //普通
        @Test
        void keys() { 
            Set<String> keys = redisUtil.keys();
            keys.forEach(System.out::println);
        }
    
        @Test
        void expire() { 
            boolean res = redisUtil.expire("pcc::city", -1);
            System.out.println(res);
        }
    
        @Test
        void getExpire() { 
            long res = redisUtil.getExpire("pcc::province");
            System.out.println(res);
        }
    
        @Test
        void exists() { 
            boolean res = redisUtil.exists("pcc:city");
            System.out.println(res);
        }
    
        @Test
        void del() { 
            redisUtil.del("dept1", "dept2");
        }
    
        //string
        @Test
        void set() { 
            Dept dept = new Dept(10, "sales", "chicago");
            redisUtil.set("dept1", dept);
        }
    
        @Test
        void set2() { 
            Dept dept = new Dept(10, "sales", "chicago");
            boolean res = redisUtil.set("dept2", dept, 120);
            System.out.println(res);
        }
    
        @Test
        void multiSet() { 
            HashMap<String, Dept> map = new HashMap<>();
            map.put("dept3", new Dept(10, "sales", "chicago"));
            map.put("dept4", new Dept(20, "research", "newyork"));
            map.put("dept5", new Dept(30, "analysis", "dalars"));
            boolean res = redisUtil.multiSet(map);
            System.out.println(res);
        }
    
        @Test
        void get() { 
            Dept dept = redisUtil.get("dept3");
            System.out.println(dept);
        }
    
        @Test
        void get2() { 
            Dept dept = redisUtil.get("dept3", Dept.class);
            System.out.println(dept);
        }
    
    
        @Test
        void incr() { 
            long res = redisUtil.incr("k1", 8);
            System.out.println(res);
        }
    
        @Test
        void decr() { 
            long res = redisUtil.decr("k1", 4);
            System.out.println(res);
        }
    
        //map-hash
        @Test
        void hset() { 
            boolean res = redisUtil.hset("h1", "dept1", new Dept(30, "analysis", "dalars"));
            System.out.println(res);
        }
    
    
        @Test
        void testHset() { 
            boolean res = redisUtil.hset("h2","30", new Dept(30, "analysis", "dalars"), 120);
            System.out.println(res);
        }
    
        @Test
        void hmset() { 
            HashMap<String, Dept> map = new HashMap<>();
            map.put("dept10", new Dept(10, "sales", "chicago"));
            map.put("dept20", new Dept(20, "research", "newyork"));
            map.put("dept30", new Dept(30, "analysis", "dalars"));
            boolean res = redisUtil.hmset("h3", map);
            System.out.println(res);
        }
    
        @Test
        void testHmset() { 
            HashMap<String, Dept> map = new HashMap<>();
            map.put("10", new Dept(10, "sales", "chicago"));
            map.put("20", new Dept(20, "research", "newyork"));
            map.put("30", new Dept(30, "analysis", "dalars"));
            boolean res = redisUtil.hmset("h4", map, 120);
            System.out.println(res);
        }
    
        @Test
        void hget() { 
            Dept res = redisUtil.hget("h3", "dept10");
            System.out.println(res);
        }
    
        @Test
        void hmget() { 
            Map<String, Dept> res = redisUtil.hmget("h3");
            res.forEach((k, v) -> System.out.println(k + "\t" + v));
        }
    
        @Test
        void hmget2() { 
            Map<String, Dept> res = redisUtil.hmget("h4");
            res.forEach((k, v) -> System.out.println(k + "\t" + v));
        }
    
        @Test
        void hdel() { 
            redisUtil.hdel("h3", "dept30", "dept20");
        }
    
        @Test
        void hHasKey() { 
            boolean res = redisUtil.hHasKey("h3", "dept10");
            System.out.println(res);
        }
    
        @Test
        void hincr() { 
            double res = redisUtil.hincr("p", "age", 20);
            System.out.println(res);
        }
    
        @Test
        void hdecr() { 
            double res = redisUtil.hdecr("p", "age", 30);
            System.out.println(res);
        }
    
        //map - set
        @Test
        void sSet() { 
            long res = redisUtil.sSet("s1", new Dept(10, "sales", "chicago"), new Dept(20, "research", "newyork"), new Dept(30, "analysis", "dalars"));
            System.out.println(res);
        }
    
    
        @Test
        void sSetWithExpire() { 
            long res = redisUtil.sSetWithExpire("s2", 120, new Dept(10, "sales", "chicago"), new Dept(20, "research", "newyork"));
            System.out.println(res);
        }
    
        @Test
        void sGet() { 
            Set<Dept> res = redisUtil.sGet("s2");
            res.forEach(System.out::println);
        }
    
        @Test
        void sHasKey() { 
            boolean res = redisUtil.sHasKey("s1", new Dept(10, "sales", "chicago"));
            System.out.println(res);
        }
    
        @Test
        void sGetSetSize() { 
            long res = redisUtil.sGetSetSize("s1");
            System.out.println(res);
        }
    
        @Test
        void setRemove() { 
            long res = redisUtil.setRemove("s1", new Dept(10, "sales", "chicago"));
            System.out.println(res);
        }
    
        // list
        @Test
        void lSet() { 
            boolean res = redisUtil.lSet("list1", new Dept(10, "sales", "chicago"));
            System.out.println(res);
        }
    
        @Test
        void testLSet() { 
            boolean res = redisUtil.lSet("list1", new Dept(20, "research", "newyork"),240);
            System.out.println(res);
        }
    
        @Test
        void testLSets() { 
            List<Dept> list = new ArrayList<>();
            list.add(new Dept(30, "sales", "chicago"));
            list.add(new Dept(40, "research", "newyork"));
            boolean res = redisUtil.lSets("list1", list);
            System.out.println(res);
        }
    
        @Test
        void testLSets1() { 
            List<Dept> list = new ArrayList<>();
            list.add(new Dept(50, "sales", "chicago"));
            list.add(new Dept(60, "research", "newyork"));
            boolean res = redisUtil.lSets("list1", list,240);
            System.out.println(res);
        }
    
            @Test
        void lGet() { 
            List<Dept> res = redisUtil.lGet("list1", 0, -1);
            System.out.println(res);
        }
        @Test
        void lGetListSize() { 
            long res = redisUtil.lGetListSize("list1");
            System.out.println(res);
        }
    
        @Test
        void lGetIndex() { 
            Object res = redisUtil.lGetIndex("list1", 3);
            System.out.println(res);
        }
    
    
        @Test
        void lUpdateIndex() { 
            boolean res = redisUtil.lUpdateIndex("list1", 3, new Dept(60, "****", "newyork"));
            System.out.println(res);
        }
    
        @Test
        void lRemove() { 
            long res = redisUtil.lRemove("list1", 3, new Dept(60, "****", "newyork"));
            System.out.println(res);
        }
    }