springboot + redis

最新推荐文章于 2024-04-17 02:50:15 发布
最新推荐文章于 2024-04-17 02:50:15 发布
阅读量2.9k 收藏 5
点赞数 1
分类专栏： # Java 文章标签： redis spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CaBCo/article/details/121993117
版权

本篇简述springboot集成redis，基于redis哨兵模式。

sproingboot 集成组件三步曲（参见springboot+JPA介绍：依赖、配置、封装）

（假定springboot脚手架已搭建完成并成功运行，可参考历史分享springboot+mybatis）

1. maven添加redis依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-redis</artifactId>
</dependency>

2. redis 配置

2.1 yml

#spring
spring：

#redis
  redis:
    host: 192.168.2.9
    port: 6379
    password: CacheDB123
    jedis:
      pool:
        max-active: 8
        max-wait: 6000
        max-idle: 5
        min-idle: 1
    # 哨兵配置
    sentinel:
      master: mymaster
      nodes: 192.168.2.9:6379,192.168.2.10:6379

2.2 RedisTemplate config

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * redis模板
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);

        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> 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);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        // key
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        // value
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

3. redis 功能封装

3.1 RedisService

import java.util.concurrent.TimeUnit;

public interface RedisService {

    /** 缓存的有效时长 **/
    long TIME_ONE_SECOND = 1; // 1秒
    long TIME_ONE_MINUTE = 60 * TIME_ONE_SECOND; // 1分
    long TIME_ONE_HOUR = 60 * TIME_ONE_MINUTE; // 1小时
    long TIME_ONE_DAY = 24 * TIME_ONE_HOUR; // 1天
    long TIME_ONE_MONTH = 30 * TIME_ONE_DAY; // 1个月

    /**
     * 获取缓存剩余时间
     * @param keys
     * @return 秒
     */
    long getExpire(String... keys);

    /**
     * 缓存数据 并 设置有效期
     * @param value
     * @param exp
     * @param unit
     * @param keys
     * @param <V>
     * @return
     */
    <V> boolean setByKey(V value, long exp, TimeUnit unit, String... keys);

    /**
     * 缓存数据 并 设置有效期（默认时间单位为秒）
     * @param value
     * @param exp
     * @param keys
     * @param <V>
     * @return
     */
    <V> boolean setByKey(V value, long exp, String... keys);

    /**
     * 缓存数据（默认存储一个月）
     * @param value
     * @param keys
     * @param <V>
     * @return
     */
    <V> boolean setByKey(V value, String... keys);

    /**
     * incr key
     * 原子递增
     * @param key
     * @param value
     * @return
     */
    long increment(String key, long value);

    /**
     * incr key
     * 原子递增
     * @param key
     * @param value
     * @param exp
     * @return
     */
    long increment(String key, long value, long exp);

    /**
     * rpush = right push (rpush key value)
     * 添加元素到List集合的尾部（默认存储时间单位为秒）
     * @param key
     * @param value 一个元素 或 一个List集合
     * @param exp
     * @param <V>
     * @return
     */
    <V> boolean rpush(String key, V value, long exp);

    /**
     * lpush = left push (lpush key value)
     * 添加元素到List集合的头部（默认存储时间单位为秒）
     * @param key
     * @param value 一个元素 或 一个List集合
     * @param exp
     * @param <V>
     * @return
     */
    <V> boolean lpush(String key, V value, long exp);

    /**
     * lrange = list range (lrange key 0 -1 即获取全部列表数据)
     * 获取List集合数据
     * @param key
     * @param <V>
     * @return
     */
    <V> V lrange(String key);

    /**
     * sadd key value
     * 添加元素到Set集合（默认存储时间单位为秒）
     * @param key
     * @param value 一个元素 或 一个Set集合
     * @param exp
     * @param <V>
     * @return
     */
    <V> boolean sadd(String key, V value, long exp);

    /**
     * smembers key
     * 获取Set集合数据
     * @param key
     * @param <V>
     * @return
     */
    <V> V smembers(String key);

    /**
     * zadd key score value (score为有序索引序列)
     * 添加元素到ZSet集合(有序)（默认存储时间单位为秒）
     * @param key
     * @param value 一个元素 或 一个Set集合
     * @param exp
     * @param <V>
     * @return
     */
    <V> boolean zadd(String key, V value, long exp);

    /**
     * zrange key 0 -1
     * 获取ZSet集合数据
     * @param key
     * @param <V>
     * @return
     */
    <V> V zrange(String key);

    /**
     * 获取Redis缓存数据
     * @param keys
     * @param <V>
     * @return
     */
    <V> V getByKey(String... keys);

    /**
     * 删除Redis缓存数据
     * @param keys
     * @return
     */
    boolean delByKey(String... keys);

    /**
     * 通过 Redis 发布订阅消息
     * @param channel
     * @param message
     */
    void convertAndSend(String channel, Object message);

}

3.2 RedisServiceImpl

import com.alibaba.fastjson.JSON;
import com.example.demo.service.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 拼接缓存数据的key
     * @param keys
     * @return
     */
    private String getMemKey(String... keys){
        if(keys == null || keys.length == 0){
            return null;
        }

        if(keys.length == 1){
            return keys[0];
        }

        StringBuffer memKey = new StringBuffer();
        Arrays.stream(keys).forEach(key -> {
            memKey.append(":");
            memKey.append(key);
        });

        return memKey.toString().replaceFirst(":", "");
    }

    /**
     * 设置缓存有效期
     * @param key
     * @param exp 默认一个月
     * @param unit 默认为秒
     * @return
     */
    private boolean expireByKey(String key, long exp, TimeUnit unit){
        if (exp == 0) {
            exp = RedisService.TIME_ONE_MONTH;
        }
        if (unit == null) {
            unit = TimeUnit.SECONDS;
        }

        return redisTemplate.expire(key, exp, unit);
    }

    @Override
    public long getExpire(String... keys) {
        String memKey = this.getMemKey(keys);
        Long expire = redisTemplate.getExpire(memKey);

        log.info("获取缓存数据剩余有效期：key-{}, value-{}", memKey, expire);

        return expire == null ? 0 : expire;
    }

    @Override
    public <V> boolean setByKey(V value, long exp, TimeUnit unit, String... keys) {
        String memKey = this.getMemKey(keys);
        redisTemplate.opsForValue().set(memKey, value);
        return this.expireByKey(memKey, exp, unit);
    }

    @Override
    public <V> boolean setByKey(V value, long exp, String... keys) {
        return setByKey(value, exp, TimeUnit.SECONDS, keys);
    }

    @Override
    public <V> boolean setByKey(V value, String... keys) {
        return setByKey(value, 0, keys);
    }

    @Override
    public long increment(String key, long value) {
        // 永不过期
        return redisTemplate.opsForValue().increment(key, value);
    }

    @Override
    public long increment(String key, long value, long exp) {
        long afterIncrementValue = redisTemplate.opsForValue().increment(key, value);
        this.expireByKey(key, exp, TimeUnit.SECONDS);
        return afterIncrementValue;
    }

    @Override
    public <V> boolean rpush(String key, V value, long exp) {
        redisTemplate.opsForList().rightPush(key, value);
        return this.expireByKey(key, exp, TimeUnit.SECONDS);
    }

    @Override
    public <V> boolean lpush(String key, V value, long exp) {
        redisTemplate.opsForList().leftPush(key, value);
        return this.expireByKey(key, exp, TimeUnit.SECONDS);
    }

    @Override
    public <V> V lrange(String key) {
        log.debug("获取缓存数据：key-{}", key);
        return (V) redisTemplate.opsForList().range(key, 0, -1);
    }

    @Override
    public <V> boolean sadd(String key, V value, long exp) {
        redisTemplate.opsForSet().add(key, value);
        return this.expireByKey(key, exp, TimeUnit.SECONDS);
    }

    @Override
    public <V> V smembers(String key) {
        log.debug("获取缓存数据：key-{}", key);
        return (V) redisTemplate.opsForSet().members(key);
    }

    @Override
    public <V> boolean zadd(String key, V value, long exp) {
        redisTemplate.opsForZSet().add(key, value, Math.random());
        return this.expireByKey(key, exp, TimeUnit.SECONDS);
    }

    @Override
    public <V> V zrange(String key) {
        log.debug("获取缓存数据：key-{}", key);
        return (V) redisTemplate.opsForZSet().range(key, 0, -1);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <V> V getByKey(String... keys) {
        String memKey = this.getMemKey(keys);
        V value = (V) redisTemplate.opsForValue().get(memKey);

        log.info("获取缓存数据：key-{}, value-{}", memKey, JSON.toJSONString(value));

        return value;
    }

    @Override
    public boolean delByKey(String... keys) {
        return redisTemplate.opsForValue().getOperations().delete(this.getMemKey(keys));
    }

    @Override
    public void convertAndSend(String channel, Object message) {
        redisTemplate.convertAndSend(channel, message);
    }

}

写在最后：

简单提下缓存三点问题：

  1. 缓存穿透：Redis及DB中都未查到数据，击穿Redis穿透DB，频繁高频请求会影响DB。可以缓存一定时长有效期的空值来拦截恶意攻击请求。
  2. 缓存击穿：某一热点数据过期，短时间内请求击穿Redis，直达DB，DB峰值飙升。可以设置热点数据永不过期。
  3. 缓存雪崩：大量热点数据在短时间内几乎同时过期了，DB瞬时压力陡升爆掉。同上可以设置热点数据永不过期或有效期随机错开。

缓存中间件Redis的生产应用模式，一般有主从模式，sentinel哨兵模式，cluster集群模式。后面有空了会在服务运维专栏聊聊各种模式的搭建及测试应用。

XYZip2
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue+springboot+redis+kaptcha实现登录验证码
04-10
vue+springboot+redis+kaptcha实现登录页验证码
Springboot+redis+mybatisplus实例
03-07
Springboot+redis+mybatisplus
Spring Boot 操作 Redis，三种方案全解析！
ssdrrg的博客
04-17 1178
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
springboot整合redis
热门推荐
lwj_07的博客
08-10 4万+
创建springboot整合redis工程： 首先我们要知道什么是redis： 三个步骤：补充：RedisTemplate对象提供了各种往redis数据库中存储数据的类型： 代码演示如下所示：注意：下面所有的步骤，要保证Redis数据库是开启的状态，要不然肯定连接不上Redis数据库 第一步： 第二步： 第三步： 又因为我们知道Redis数据库支持多种格式的存储数据形式，因此还可以往Redis数据库中存储哈希类型的数据（哈希类型：就类似于一个key里面又放入一个key，value），因此Redis
Redis分布式锁的正确使用姿势
施小楠的博客
06-08 1700
前言 日常开发中，秒杀下单、抢红包等等业务场景，都需要用到分布式锁。而Redis非常适合作为分布式锁使用。本文将分七个方案展开，跟大家探讨Redis分布式锁的正确使用方式。如果有不正确的地方，欢迎大家指出哈，一起学习一起进步。 公众号：捡田螺的小男孩 什么是分布式锁 方案一：SETNX + EXPIRE 方案二：SETNX + value值是（系统时间+过期时间） 方案三：使用Lua脚本(包含SETNX + EXPIRE两条指令) 方案四：SET的扩展命令（
springboot+redis
SieSteven
04-23 121
向既有项目（springboot2.x）中添加redis作为缓存
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
SpringBoot整合Redis[详细版]
wang20000102的博客
09-04 6677
SpringBoot整合Redis[详细版]Redis是现在最受欢迎的NoSQL数据库之一，Redis是一个使用ANSI C编写的开源。spring-boot-starter-data-redis在SpringBoot中集成了两个模版一个是RedisTemplate，另一个为 StringRedisTemplate而虽然StringRedisTempate帮助我们做了序列化，但是存储数据的时候只能存储Sting类型的数据，而RedisTemplate可以存储Object类型，所以我们一个使用RedisT
springboot+redis过期事件监听实现过程解析
08-19
SpringBoot+Redis过期事件监听实现过程解析 本文主要介绍了SpringBoot+Redis过期事件监听实现过程的详细解析，旨在帮助读者更好地理解和掌握相关技术。通过示例代码的详细介绍，对大家的学习或者工作具有一定的参考...
springboot+redis实现查询附近商铺功能.zip
05-20
springboot+redis实现查询附近商铺功能.zip
springboot+redis(luttuce)+Protobuf
10-18
springboot整合redis选用 `Lettuce` 作为redis框架，选用 `Protobuf` 作为序列化框架
SpringBoot 整合Redis 实战篇
每日一记，每周一结。
07-04 1147
在上篇文章中我们整合了redis，当我们存入一个对象时会发现redis中的数据存在乱码问题，这是jdk编码的问题。
SpringBoot揭密：spring-boot-starter-data-redis
zhangweiocp的专栏
12-04 1万+
一. POM解析 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>2.0.0.RELEASE</version> <scope>comp
SpringBoot篇——SpringBoot集成Redis，详细教程，一篇搞定！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
11-29 1907
一、首先我们需要了解为什么我们非得要自定义redisTemplate呢？源码中的模板对于数据序列化是这么处理的二、编写流程在config包下新建一个类，命名为RedisConfig，将来关于Redis的配置都写在这个类中即可这段配置，如果我们真正项目中用到了redis，直接拿着用//Redis配置类，需要用@Configuration注解标记这个类是一个配置类//现在这个配置类是一个固定的模板，如果需要配置redis，直接拿走用即可。
springboot整合redis详细教程
weixin_47976194的博客
01-09 1349
注意：本次实验环境 是将 redis 安装在 CentOS7.x-86_x64 中 教程中用到的软件（VMware Workstation Pro、postman、idea、Another Redis Desktop Manager、FinalShell（xshell也可）、DBeaver（数据库客户端就行））
redis+springboot
weixin_45063957的博客
08-30 118
Jedis 是直连模式，在多个线程间共享⼀个 Jedis 实例时是线程不安全的,需要使⽤连接池 其API提供了⽐较全⾯的Redis命令的⽀持，相⽐于其他Redis 封装框架更加原⽣Jedis中的⽅法调⽤是⽐较底层的暴露的Redis的API，Java⽅法基本和Redis的API保持着⼀致使⽤阻塞的I/O，⽅法调⽤同步，程序流需要等到socket处理完I/O才能执⾏，不⽀持异步操作。 lettuce：⾼级Redis客户端，⽤于线程安全同步，异步响应基于Netty的的事件驱动，可以在多个线程间并发访问,通过异步
SpringBoot + Redis：基本配置及使用
weixin_34184158的博客
06-17 181
注：本篇博客SpringBoot版本为2.1.5.RELEASE，SpringBoot1.0版本有些配置不适用 一、SpringBoot 配置Redis 　　1.1 pom 引入spring-boot-starter-data-redis 包 <dependency> <groupId>org.springframewor...
springboot +redis
最新发布
06-05
Spring Boot 是一种开源的 Java 开发框架，可帮助开发者快速构建 Spring 应用程序。Redis 是一个开源的内存数据结构存储系统，支持不同种类的数据结构，如字符串、哈希表、列表、集合和有序集合。Spring Boot 和 Redis 结合使用，可以构建高性能、可伸缩的应用程序。 Spring Boot 提供了对 Redis 的集成支持，使得开发者可以方便地使用 Redis 存储和检索数据。通过使用 Spring Data Redis，我们可以轻松地将 Redis 数据库连接到 Spring 应用程序中，并通过提供模板类来操作 Redis 数据库。 以下是 Spring Boot + Redis 的一些常见应用场景： 1. 缓存数据 - Redis 是一种高效的内存数据库，适合用来缓存数据，可以提高应用程序的性能。 2. 分布式锁 - Redis 支持分布式锁，可以解决并发问题。 3. 计数器和排行榜 - Redis 支持原子计数器操作，可以用来实现排行榜等功能。 4. 发布/订阅消息 - Redis 支持发布/订阅模式，可以用来实现消息队列等功能。 如果您想了解更多关于 Spring Boot 和 Redis 的信息，可以参考 Spring Boot 官方文档和 Redis 官方文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值