《微服务实战》第二十四章 Spring boot 操作 Redis

超、凢脫俗 2023-10-10 22:59 4阅读 0赞

## 系列文章目录 ##

[第二十八章 分布式锁框架-Redisson][_-Redisson]  
[第二十四章 Spring boot 操作 Redis][Spring boot _ Redis]  
[第二十三章 Redis RDB AOF][Redis RDB AOF]  
[第二十一、二十二章 Redis发布订阅、事务；HyperLoglog基数统计][Redis_HyperLoglog]  
[第二十章 Redis连接指令 客户端指令 服务器指令][Redis_ _]  
[第十九章 Redis key][Redis key]  
[第十八章 Redis查看配置文件和数据类型][Redis]  
[第十七章 Redis下载与安装][Redis 1]

![在这里插入图片描述][c416fe4952ad460b93c14a611c8406e5.png]

--------------------

#### 文章目录 ####

*  系列文章目录
 *  前言
 *  1、新增模块 redis-service
 *  2、新增依赖
 *  3、新增配置类
 *  4、新增redis操作工具类
 *  5、配置文件application.yml
 *  6、测试

--------------------

## 前言 ##

基于Spring Cloud的项目，通过Spring boot 集成并操作Redis。  
spring-data-redis链接: https://spring.io/projects/spring-data-redis  
spring redis docs链接: https://docs.spring.io/spring-data/data-redis/docs/current/reference/html/\#redis:template

## 1、新增模块 redis-service ##

添加redis-service，去操作redis  
![在这里插入图片描述][75ade097fd5844729ddd84f918b0c543.png]

## 2、新增依赖 ##

在springboot项目里，添加redis依赖包：spring-boot-starter-data-redis

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.company</groupId>
            <artifactId>drp-common-service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

## 3、新增配置类 ##

通过@Configuration配置RedisTemplate， 在系统启动时加载RedisTemplate实例

package com.xxxx.springCloud.redis.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * Redis配置类
     */
    @Configuration
    public class RedisConfiguration {
        
        @Bean
        public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){
        
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            //配置序列化对象
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
            //采用lettuce连接redis
            redisTemplate.setConnectionFactory(lettuceConnectionFactory);
            return redisTemplate;
        }
    }

## 4、新增redis操作工具类 ##

使用RedisTemplate，对Redis进行操作

package com.xxxx.springCloud.redis.utils;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.DefaultTypedTuple;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Redis工具类
     */
    @Component
    public class RedisUtil {
        
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        // ============================= 公共方法 ============================
        /**
         * 指定缓存失效时间
         * @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 时间(秒) 返回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 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
        
            if (key != null && key.length > 0) {
        
                if (key.length == 1) {
        
                    redisTemplate.delete(key[0]);
                } else {
        
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }
    
        // ============================ String类型 =============================
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
        
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
        
            try {
        
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 普通缓存放入并设置时间
         * @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 {
        
                    set(key, value);
                }
                return true;
            } 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);
        }
    
        // ================================ Map类型 =================================
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key, String item) {
        
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
        
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map<String, Object> 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, Object> map, long time) {
        
            try {
        
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
        
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
        
            try {
        
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time) {
        
            try {
        
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
        
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         * @param key 键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
        
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
        
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         * @param key 键
         * @param item 项
         * @param by 要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item, double by) {
        
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         * @param key 键
         * @param item 项
         * @param by 要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item, double by) {
        
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        // ============================ Set类型 =============================
        /**
         * 根据key获取Set中的所有值
         * @param key 键
         * @return
         */
        public Set<Object> 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, Object value) {
        
            try {
        
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
        
            try {
        
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param set 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Set<Object> set) {
        
            try {
        
                return redisTemplate.opsForSet().add(key, set.toArray());
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         * @param key 键
         * @param time 时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, Object... values) {
        
            try {
        
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0)
                    expire(key, time);
                return count;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取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, Object... values) {
        
            try {
        
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        // =============================== List类型 =================================
        /**
         * 获取list缓存的内容
         * @param key 键
         * @param start 开始
         * @param end 结束 0 到 -1代表所有值
         * @return
         */
        public List<Object> 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>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
         * @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 value 值
         * @return
         */
        public boolean lSet(String key, Object 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, Object 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 lSet(String key, List<Object> 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 lSet(String key, List<Object> 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 index 索引
         * @param value 值
         * @return
         */
        public boolean lUpdateIndex(String key, long index, Object 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, Object value) {
        
            try {
        
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /******************zset***********************/
        /**
         * 设置zset的值
         * @param key
         * @param value
         * @param score
         * @param time 过期时间（秒）
         * @return
         */
        public boolean zSet(String key,Object value,double score,long time){
        
            try{
        
                ZSetOperations zSetOperations = redisTemplate.opsForZSet();
                zSetOperations.add(key,value,score);
                this.expire(key,time);
                return true;
            }catch (Exception e){
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 设置szet的值
         * @param key
         * @param set
         * @param time
         * @return
         */
        public boolean zSet(String key,Set<ZSetOperations.TypedTuple> set,long time){
        
            try{
        
                ZSetOperations zSetOperations = redisTemplate.opsForZSet();
                zSetOperations.add(key,set);
                this.expire(key,time);
                return true;
            }catch (Exception e){
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 获取zset的值
         * @param key
         * @return
         */
        public Set<Object> zGet(String key){
        
            ZSetOperations zSetOperations = redisTemplate.opsForZSet();
            Long size = zSetOperations.size(key);
            return zSetOperations.range(key,0,size - 1);
        }
    }

## 5、配置文件application.yml ##

通过springboot的application.yml文件，在启动时加载redis配置，包括redis服务器地址、端口等

server:
      port: 8002
    spring:
      application:
        name: redis-service
      #***********************redis***********************
      redis: #redis配置
        database: 0 # Redis数据库索引（默认为0）
        host: 127.0.0.1 # Redis服务器地址
        port: 6379 # Redis服务器连接端口
        password: 123456
        lettuce: #lettuce客户端配置
          pool: #连接池配置
            max-active: 50 # 连接池最大连接数（使用负值表示没有限制） 默认 8
            max-wait: 10 # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
            max-idle: 20 # 连接池中的最大空闲连接 默认 8
            min-idle: 10 # 连接池中的最小空闲连接 默认 0
        timeout: 1000 # 连接超时时间（毫秒）

## 6、测试 ##

测试redis的使用

@Test
    public void test(){
        
        Set<ZSetOperations.TypedTuple> set = new HashSet<>();
        set.add(new DefaultTypedTuple("Java",1.0));
        set.add(new DefaultTypedTuple("C++",5.0));
        set.add(new DefaultTypedTuple("Php",3.0));
        set.add(new DefaultTypedTuple("go",2.0));
        set.add(new DefaultTypedTuple("Hadoop",4.0));
    
        this.redisUtil.zSet("springCloud:redis:zset",set,60);
    
        Set<Object> objects = this.redisUtil.zGet("springCloud:redis:zset");
    
        for (Object object : objects) {
        
            System.out.println(object);
        }
    }

[_-Redisson]: https://blog.csdn.net/s445320/article/details/131132334
[Spring boot _ Redis]: https://blog.csdn.net/s445320/article/details/130888590
[Redis RDB AOF]: https://blog.csdn.net/s445320/article/details/130888380
[Redis_HyperLoglog]: https://blog.csdn.net/s445320/article/details/130887969
[Redis_ _]: https://blog.csdn.net/s445320/article/details/130887448
[Redis key]: https://blog.csdn.net/s445320/article/details/130885855
[Redis]: https://blog.csdn.net/s445320/article/details/130840157
[Redis 1]: https://blog.csdn.net/s445320/article/details/130830753
[c416fe4952ad460b93c14a611c8406e5.png]: https://img-blog.csdnimg.cn/c416fe4952ad460b93c14a611c8406e5.png
[75ade097fd5844729ddd84f918b0c543.png]: https://img-blog.csdnimg.cn/75ade097fd5844729ddd84f918b0c543.png