spring boot 学习 redis-缓存

╰+攻爆jí腚メ 2022-04-24 22:44 231阅读 0赞

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>

** redis基本配置**

# REDIS
    # Redis数据库索引（默认为0）
    spring.redis.database=0
    # Redis服务器地址 （默认为127.0.0.1）
    spring.redis.host=192.168.1.16
    # Redis服务器连接端口 （默认为6379）
    spring.redis.port=6379
    # Redis服务器连接密码（默认为空）
    spring.redis.password=
    # 连接超时时间（毫秒）
    spring.redis.timeout=5000ms
    # 连接池最大连接数（使用负值表示没有限制）
    spring.redis.lettuce.pool.min-idle=16
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.lettuce.pool.max-wait=5000ms
    # 连接池中的最大空闲连接
    spring.redis.lettuce.pool.max-idle=8
    # 连接池中的最小空闲连接
    spring.redis.lettuce.pool.max-active=3

**集群配置方式**

spring:
        redis:
            lettuce:
            pool:
                max-active: 8
                max-idle: 8
                max-wait: -1ms
                min-idle: 0
            sentinel:
            master: mymaster
            nodes: 192.168.145.128:26379,192.168.145.128:26380,192.168.145.128:26381

redisTemplate序列化

@Configuration
    public class RedisConfig {
    
        /**
         * 内存占用小，速度快，可读性差
         * key StringRedisSerializer
         * value JdkSerializationRedisSerializer
         * @param factory
         * @return
         */
    //    @Bean()
    //    public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
    //        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    //        redisTemplate.setConnectionFactory(factory);
    //        redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型
    //        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); // value的序列化类型
    //        return redisTemplate;
    //    }
    
        /**
         * 内存占用较大，速度最快，可读性好
         * key StringRedisSerializer
         * value jackson2JsonRedisSerializer
         * @param factory
         * @return
         */
        @Bean
        public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            redisTemplate.setConnectionFactory(factory);
            redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型
    
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
            return redisTemplate;
        }
    }

** 分组设置过期时间**

/**
     * Created on 2019/4/29.
     * 缓存管理器
     * @author Grak
     * @since 1.0
     */
    @Configuration
    public class GrayCacheConfig {
    
        /**
         * 缓存key生成器
         * @return
         */
        @Bean("grayKeyGenerator")
        public KeyGenerator keyGenerator(){
            KeyGenerator generator = new KeyGenerator(){
    
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    if(params==null||params.length==0||params[0]==null){
                        return null;
                    }
                    Object first = params[0];
                    if(first instanceof User){
                       User user = (User)first;
                        return user.getId();
                    }
                    return first;
                }
            };
            return generator;
        }
    
        /**
         * 按照注解名称配置过期时间
         * @param redisConnectionFactory
         * @return
         */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            return new RedisCacheManager(
                    RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                    this.getRedisCacheConfigurationWithTtl(24*30*60), // 默认使用过期时间
                    this.getRedisCacheConfigurationMap() // 指定 key 使用过期时间
            );
        }
    
        private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
            //SsoCache和BasicDataCache进行过期时间配置
            redisCacheConfigurationMap.put("SsoCache", this.getRedisCacheConfigurationWithTtl(24*60*60));
            redisCacheConfigurationMap.put("BasicDataCache", this.getRedisCacheConfigurationWithTtl(30*60));
            redisCacheConfigurationMap.put("User", this.getRedisCacheConfigurationWithTtl(20));
            return redisCacheConfigurationMap;
        }
    
        private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
            redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                    RedisSerializationContext
                            .SerializationPair
                            .fromSerializer(jackson2JsonRedisSerializer)
            ).entryTtl(Duration.ofSeconds(seconds));
    
            return redisCacheConfiguration;
        }
    
    }

** 当前User配置的是20秒过期**

@CacheConfig(cacheNames = "User")
    @RestController
    public class UserController {
    
        @Autowired
        UserRepository userRepository;
    
        @GetMapping("/user/{id}")
        @Cacheable(keyGenerator = "grayKeyGenerator")
        public User getUser(@PathVariable("id") int id){
            System.out.println("数据库中获取值");
            User user = userRepository.findById(id).get();
            return user;
        }
    
        @GetMapping("/user")
        @CachePut(keyGenerator = "grayKeyGenerator")
        public User insertUser(User user){
            User save = userRepository.save(user);
            return save;
        }
    
        @GetMapping("/del")
        @CacheEvict(keyGenerator = "grayKeyGenerator")
        public void deleteUser(int id){
            userRepository.deleteById(id);
            System.out.println("删除信息:" + id);
        }

**redisTemplate工具类**

/**
     * @author yangaliang
     * 基于spring和redis的redisTemplate工具类
     * 针对所有的hash 都是以h开头的方法
     * 针对所有的Set 都是以s开头的方法
     * 针对所有的List 都是以l开头的方法
     */
    @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(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 by 要增加几(大于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 by 要减少几(小于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 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 值
         *   * @param time 时间(秒)
         *   * @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 值
         *   * @param time 时间(秒)
         *   * @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;
            }
        }
    
    }