首页 > 数据库 >spring boot集成redis

spring boot集成redis

时间:2024-05-21 10:09:19浏览次数:25  
标签:redis String spring Object boot Long key public redisTemplate

  1. Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。

  2. Redis 常用数据类型使用场景:

    • String,存短信验证码、缓存、计数器、分布式session
    • List,发布订阅等
    • Set,共同好友、点赞或点踩等
    • Hash,存储对象
    • Zset,排行榜
    • HyperLogLog,在线用户数、统计访问量等
    • GeoHash,同城的人、同城的店等
    • BitMap,签到打卡、活跃用户等
  3. 实现步骤:

    • 引入依赖:项目中引入spring-boot-starter-data-redis后默认使用Lettuce作为Redis客户端库。与老牌的Jedis客户端相比,Lettuce功能更加强大,不仅解决了线程安全的问题,还支持异步和响应式编程,支持集群,Sentinel,管道和编码器等等功能。

      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 解决在实体类使用java.time包下的LocalDateTime、LocalDate等类时序列化/反序列化报错的问题 -->
        <dependency>
          <groupId>com.fasterxml.jackson.datatype</groupId>
          <artifactId>jackson-datatype-jsr310</artifactId>
          <version>2.13.0</version>
        </dependency>
      </dependencies>
      
    • 修改配置文件

      spring:
        data:
          redis:
            host: localhost     # Redis服务器地址
            port: 6379          # Redis服务器连接端口
            password: 123456    # Redis服务器连接密码(默认为空)
            database: 0         # Redis数据库索引(默认为0)
            timeout: 60s        # 连接空闲超过N(s秒、ms毫秒,不加单位时使用毫秒)后关闭,0为禁用,这里配置值和tcp-keepalive值一致
            # Lettuce连接池配置
            lettuce:
              pool:
                max-active: 10  # 允许最大连接数,默认8(负值表示没有限制),推荐值:大于cpu * 2,通常为(cpu * 2) + 2
                max-idle: 8     # 最大空闲连接数,默认8,推荐值:cpu * 2
                min-idle: 0     # 最小空闲连接数,默认0
                max-wait: 5s    # 连接用完时,新的请求等待时间(s秒、ms毫秒),超过该时间抛出异常,默认-1(负值表示没有限制)
      
    • 定义Redis配置类:在Redis配置类中,声明了一个自定义的RedisTemplate<String, Object>和一个自定义的Redis序列化器RedisSerializer

    /**
     * Redis相关Bean配置
     */
    @Configuration
    public class RedisConfig {
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisSerializer<Object> serializer = redisSerializer();
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(serializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(serializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        @Bean
        public RedisSerializer<Object> redisSerializer() {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            //必须设置,否则无法将JSON转化为对象,会转化成Map类型
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
    
            // 自定义ObjectMapper的时间处理模块
            JavaTimeModule javaTimeModule = new JavaTimeModule();
    
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    
            javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
            javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
    
            javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
            javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
    
            objectMapper.registerModule(javaTimeModule);
    
            // 禁用将日期序列化为时间戳的行为
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    
            //创建JSON序列化器
            return new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
        }
    }
    
    • 定义Redis服务类,封装Redis常用操作
    /**
     * Redis操作服务类
     */
    public interface RedisService {
    
        /**
         * 保存属性
         *
         * @param time 超时时间(秒)
         */
        void set(String key, Object value, long time);
    
        /**
         * 保存属性
         */
        void set(String key, Object value);
    
        /**
         * 获取属性
         */
        Object get(String key);
    
        /**
         * 删除属性
         */
        Boolean del(String key);
    
        /**
         * 批量删除属性
         */
        Long del(List<String> keys);
    
        /**
         * 设置过期时间
         */
        Boolean expire(String key, long time);
    
        /**
         * 获取过期时间
         */
        Long getExpire(String key);
    
        /**
         * 判断是否有该属性
         */
        Boolean hasKey(String key);
    
        /**
         * 按delta递增
         */
        Long incr(String key, long delta);
    
        /**
         * 按delta递减
         */
        Long decr(String key, long delta);
    
        /**
         * 获取Hash结构中的属性
         */
        Object hGet(String key, String hashKey);
    
        /**
         * 向Hash结构中放入一个属性
         */
        Boolean hSet(String key, String hashKey, Object value, long time);
    
        /**
         * 向Hash结构中放入一个属性
         */
        void hSet(String key, String hashKey, Object value);
    
        /**
         * 直接获取整个Hash结构
         */
        Map<Object, Object> hGetAll(String key);
    
        /**
         * 直接设置整个Hash结构
         */
        Boolean hSetAll(String key, Map<String, Object> map, long time);
    
        /**
         * 直接设置整个Hash结构
         */
        void hSetAll(String key, Map<String, ?> map);
    
        /**
         * 删除Hash结构中的属性
         */
        void hDel(String key, Object... hashKey);
    
        /**
         * 判断Hash结构中是否有该属性
         */
        Boolean hHasKey(String key, String hashKey);
    
        /**
         * Hash结构中属性递增
         */
        Long hIncr(String key, String hashKey, Long delta);
    
        /**
         * Hash结构中属性递减
         */
        Long hDecr(String key, String hashKey, Long delta);
    
        /**
         * 获取Set结构
         */
        Set<Object> sMembers(String key);
    
        /**
         * 向Set结构中添加属性
         */
        Long sAdd(String key, Object... values);
    
        /**
         * 向Set结构中添加属性
         */
        Long sAdd(String key, long time, Object... values);
    
        /**
         * 是否为Set中的属性
         */
        Boolean sIsMember(String key, Object value);
    
        /**
         * 获取Set结构的长度
         */
        Long sSize(String key);
    
        /**
         * 删除Set结构中的属性
         */
        Long sRemove(String key, Object... values);
    
        /**
         * 获取List结构中的属性
         */
        List<Object> lRange(String key, long start, long end);
    
        /**
         * 获取List结构的长度
         */
        Long lSize(String key);
    
        /**
         * 根据索引获取List中的属性
         */
        Object lIndex(String key, long index);
    
        /**
         * 向List结构中添加属性
         */
        Long lPush(String key, Object value);
    
        /**
         * 向List结构中添加属性
         */
        Long lPush(String key, Object value, long time);
    
        /**
         * 向List结构中批量添加属性
         */
        Long lPushAll(String key, Object... values);
    
        /**
         * 向List结构中批量添加属性
         */
        Long lPushAll(String key, Long time, Object... values);
    
        /**
         * 从List结构中移除属性
         */
        Long lRemove(String key, long count, Object value);
    }
    
    • RedisService实现类定义
    
    /**
     * Redis操作实现类
     */
    @Service
    public class RedisServiceImpl implements RedisService {
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        @Override
        public void set(String key, Object value, long time) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        }
    
        @Override
        public void set(String key, Object value) {
            redisTemplate.opsForValue().set(key, value);
        }
    
        @Override
        public Object get(String key) {
            return redisTemplate.opsForValue().get(key);
        }
    
        @Override
        public Boolean del(String key) {
            return redisTemplate.delete(key);
        }
    
        @Override
        public Long del(List<String> keys) {
            return redisTemplate.delete(keys);
        }
    
        @Override
        public Boolean expire(String key, long time) {
            return redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    
        @Override
        public Long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        @Override
        public Boolean hasKey(String key) {
            return redisTemplate.hasKey(key);
        }
    
        @Override
        public Long incr(String key, long delta) {
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        @Override
        public Long decr(String key, long delta) {
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        @Override
        public Object hGet(String key, String hashKey) {
            return redisTemplate.opsForHash().get(key, hashKey);
        }
    
        @Override
        public Boolean hSet(String key, String hashKey, Object value, long time) {
            redisTemplate.opsForHash().put(key, hashKey, value);
            return expire(key, time);
        }
    
        @Override
        public void hSet(String key, String hashKey, Object value) {
            redisTemplate.opsForHash().put(key, hashKey, value);
        }
    
        @Override
        public Map<Object, Object> hGetAll(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        @Override
        public Boolean hSetAll(String key, Map<String, Object> map, long time) {
            redisTemplate.opsForHash().putAll(key, map);
            return expire(key, time);
        }
    
        @Override
        public void hSetAll(String key, Map<String, ?> map) {
            redisTemplate.opsForHash().putAll(key, map);
        }
    
        @Override
        public void hDel(String key, Object... hashKey) {
            redisTemplate.opsForHash().delete(key, hashKey);
        }
    
        @Override
        public Boolean hHasKey(String key, String hashKey) {
            return redisTemplate.opsForHash().hasKey(key, hashKey);
        }
    
        @Override
        public Long hIncr(String key, String hashKey, Long delta) {
            return redisTemplate.opsForHash().increment(key, hashKey, delta);
        }
    
        @Override
        public Long hDecr(String key, String hashKey, Long delta) {
            return redisTemplate.opsForHash().increment(key, hashKey, -delta);
        }
    
        @Override
        public Set<Object> sMembers(String key) {
            return redisTemplate.opsForSet().members(key);
        }
    
        @Override
        public Long sAdd(String key, Object... values) {
            return redisTemplate.opsForSet().add(key, values);
        }
    
        @Override
        public Long sAdd(String key, long time, Object... values) {
            Long count = redisTemplate.opsForSet().add(key, values);
            expire(key, time);
            return count;
        }
    
        @Override
        public Boolean sIsMember(String key, Object value) {
            return redisTemplate.opsForSet().isMember(key, value);
        }
    
        @Override
        public Long sSize(String key) {
            return redisTemplate.opsForSet().size(key);
        }
    
        @Override
        public Long sRemove(String key, Object... values) {
            return redisTemplate.opsForSet().remove(key, values);
        }
    
        @Override
        public List<Object> lRange(String key, long start, long end) {
            return redisTemplate.opsForList().range(key, start, end);
        }
    
        @Override
        public Long lSize(String key) {
            return redisTemplate.opsForList().size(key);
        }
    
        @Override
        public Object lIndex(String key, long index) {
            return redisTemplate.opsForList().index(key, index);
        }
    
        @Override
        public Long lPush(String key, Object value) {
            return redisTemplate.opsForList().rightPush(key, value);
        }
    
        @Override
        public Long lPush(String key, Object value, long time) {
            Long index = redisTemplate.opsForList().rightPush(key, value);
            expire(key, time);
            return index;
        }
    
        @Override
        public Long lPushAll(String key, Object... values) {
            return redisTemplate.opsForList().rightPushAll(key, values);
        }
    
        @Override
        public Long lPushAll(String key, Long time, Object... values) {
            Long count = redisTemplate.opsForList().rightPushAll(key, values);
            expire(key, time);
            return count;
        }
    
        @Override
        public Long lRemove(String key, long count, Object value) {
            return redisTemplate.opsForList().remove(key, count, value);
        }
    }
    
    • 使用Redis服务类
    @Service
    public class AuthServiceImpl extends AuthService {
    
        private final RedisService redisService;
    
        public AuthServiceImpl(RedisService redisService) {
            this.redisService = redisService;
        }
    
        public String login(LoginParam param) {
    
            // 在Redis中增加一条在线用户记录
            redisService.set("OnlineUser:" + user.getUsername() + ":" + token, user);
    
            return token;
        }
    
        public void logout() {
    
            // 删除Redis中当前用户记录
            redisService.del("OnlineUser:" + user.getUsername() + ":" + token);
        }
    }
    

标签:redis,String,spring,Object,boot,Long,key,public,redisTemplate
From: https://www.cnblogs.com/hytip/p/18203369

相关文章

  • springboot2 - validation
    业务需求:客户端提交的表单,后台需要有统一的校验拦截机制。Maven依赖除了hibernate-validator,springboot本身自带这些依赖。<dependencys><dependency><groupId>jakarta.validation</groupId><artifactId>jakarta.validation-api</artifactId>......
  • Java开发Spring常见注解
    Java开发Spring常见注解  前言  Spring的一个核心功能是IOC,就是将Bean初始化加载到容器中,Bean是如何加载到容器的,可以使用Spring注解方式或者SpringXML配置方式。  注解本身没有功能的,就和xml一样。注解和xml都是一种元数据,元数据即解释数据的数据,这就是所谓配置......
  • 一次redis和内存的qps比较
    不同缓存策略下的性能指标:无缓存|Redis|直接内存1.无缓存测试结果2.加入Redis缓存后性能翻倍6-73.直接用内存(错误写法)错误写法的性能指标正确写法(双检单例模式)正确写法后,性能......
  • springboot2 - lettuce
    spring操作redis,默认使用的是lettuce,介绍一下相关代码。Maven依赖<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency>......
  • 聊聊如何利用spring实现服务隔离
    前言假设我们有个场景,我们需要实现服务之间的数据隔离、配置隔离、依赖的springbean之间隔离。大家会有什么实现思路?今天给大家介绍spring-cloud-context里面有个NamedContextFactory可以达到上面的效果NamedContextFactory简介NamedContextFactory可以实现子容器,通过它创建子......
  • spring boot中的定时任务
    SpringBoot中的定时任务主要通过@Scheduled注解以及SchedulingConfigurer接口实现。@Scheduled注解是Spring提供的一个注解,用于标记方法作为定时任务执行:配置方法在指定的时间间隔或时间点执行,实现各种定时任务需求。//在你需要定时的方法上加上@Scheduled注解,并用corn表达......
  • springboot2 - ehcache
    介绍ehcache一下在spring环境下的应用。如果是单机系统,ehcache一般是首选方案,想通过切换redis提高性能,意义不大,反而会增加部署和维护负担。工具函数如果想在spring环境下,封装自己的工具函数,下面这些基础代码估计会用到。场景:像是Excel导入数据,需要大批量更新缓存时......
  • spring boot 邮件发送
    之前的发邮件的话比较繁琐,springbbot帮我们简化了开发,引入mail的启动类支持<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-mail</artifactId></dependency>既然springboot中已经配置了,说明它里面肯定有一个关于mail......
  • SpringCache
    实现了基于注解的缓存功能导入依赖org.springframwork.bootspring-boot-starter-cachespring-boot-starter-data-redis2.7.3@EnableCaching一般放在启动类上,表示我们使用基于注解的缓存功能----开启缓存注解功能@Cacheable一般加在方法上,如果查询到缓存,就返回缓存数据......
  • Spring 对 Junit4,Junit5 的支持上的运用
    1.Spring对Junit4,Junit5的支持上的运用@目录1.Spring对Junit4,Junit5的支持上的运用每博一文案2.Spring对Junit4的支持3.Spring对Junit5的支持4.总结:5.最后:每博一文案关于理想主义,在知乎上看到一句话:“他们并不是不懂别人口中的现实,他们只是不信,事情只能是现在......