SpringBoot高级篇Redis之基本配置

最新推荐文章于 2024-10-16 16:32:35 发布
最新推荐文章于 2024-10-16 16:32:35 发布
阅读量486 收藏 1
点赞数
文章标签： 数据库 java python
原文链接：https://my.oschina.net/u/566591/blog/2254399
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

更多Spring文章，欢迎点击 一灰灰Blog-Spring专题

在Spring的应用中，redis可以算是基础操作了。那么想要玩转redis，我们需要知道哪些知识点呢？

  • redis配置，默认，非默认，集群，多实例，连接池参数等
  • redis读写操作，RedisTemplate的基本使用姿势
  • 几种序列化方式对比

本篇博文为redis系列的开篇，将介绍最基本的配置

<!-- more -->

I. redis基本配置

1. 默认配置

最简单的使用其实开箱即可用，添加依赖

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

本机启动redis，一切采用默认的配置 （host:127.0.0.1, port:6379, 无密码)

然后就可以愉快的玩耍了，可以直接注入redisTemplate实例，进行各种读写操作

@SpringBootApplication
public class Application {

    public Application(RedisTemplate<String, String> redisTemplate) {
        redisTemplate.opsForValue().set("hello", "world");
        String ans = redisTemplate.opsForValue().get("hello");
        Assert.isTrue("world".equals(ans));
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. 自定义配置参数

前面是默认的配置参数，在实际的使用中，一般都会修改这些默认的配置项，如果我的应用中，只有一个redis，那么完全可以只修改默认的配置参数

修改配置文件: application.yml

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    database: 0
    lettuce:
      pool:
        max-active: 32
        max-wait: 300ms
        max-idle: 16
        min-idle: 8

使用和前面没有什么区别，直接通过注入RedisTemplate来操作即可，需要额外注意的是设置了连接池的相关参数，需要额外引入依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

3. 多redis配置

依赖多个不同的redis，也就是说我的项目需要从多个redis实例中获取数据，这种时候，就不能直接使用默认的，需要我们自己来声明ConnectionFactory和 RedisTemplate

配置如下

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    lettuce:
      pool:
        max-active: 32
        max-wait: 300
        max-idle: 16
        min-idle: 8
    database: 0
  local-redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    password:
    lettuce:
      pool:
        max-active: 16
        max-wait: 100
        max-idle: 8
        min-idle: 4

对应的配置类，采用Lettuce，基本设置如下，套路都差不多，先读取配置，初始化ConnectionFactory，然后创建RedisTemplate实例，设置连接工厂

@Configuration
public class RedisAutoConfig {

    @Bean
    public LettuceConnectionFactory defaultLettuceConnectionFactory(RedisStandaloneConfiguration defaultRedisConfig,
            GenericObjectPoolConfig defaultPoolConfig) {
        LettuceClientConfiguration clientConfig =
                LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(100))
                        .poolConfig(defaultPoolConfig).build();
        return new LettuceConnectionFactory(defaultRedisConfig, clientConfig);
    }

    @Bean
    public RedisTemplate<String, String> defaultRedisTemplate(
            LettuceConnectionFactory defaultLettuceConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(defaultLettuceConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    @ConditionalOnBean(name = "localRedisConfig")
    public LettuceConnectionFactory localLettuceConnectionFactory(RedisStandaloneConfiguration localRedisConfig,
            GenericObjectPoolConfig localPoolConfig) {
        LettuceClientConfiguration clientConfig =
                LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(100))
                        .poolConfig(localPoolConfig).build();
        return new LettuceConnectionFactory(localRedisConfig, clientConfig);
    }

    @Bean
    @ConditionalOnBean(name = "localLettuceConnectionFactory")
    public RedisTemplate<String, String> localRedisTemplate(LettuceConnectionFactory localLettuceConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(localLettuceConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Configuration
    @ConditionalOnProperty(name = "host", prefix = "spring.local-redis")
    public static class LocalRedisConfig {
        @Value("${spring.local-redis.host:127.0.0.1}")
        private String host;
        @Value("${spring.local-redis.port:6379}")
        private Integer port;
        @Value("${spring.local-redis.password:}")
        private String password;
        @Value("${spring.local-redis.database:0}")
        private Integer database;

        @Value("${spring.local-redis.lettuce.pool.max-active:8}")
        private Integer maxActive;
        @Value("${spring.local-redis.lettuce.pool.max-idle:8}")
        private Integer maxIdle;
        @Value("${spring.local-redis.lettuce.pool.max-wait:-1}")
        private Long maxWait;
        @Value("${spring.local-redis.lettuce.pool.min-idle:0}")
        private Integer minIdle;

        @Bean
        public GenericObjectPoolConfig localPoolConfig() {
            GenericObjectPoolConfig config = new GenericObjectPoolConfig();
            config.setMaxTotal(maxActive);
            config.setMaxIdle(maxIdle);
            config.setMinIdle(minIdle);
            config.setMaxWaitMillis(maxWait);
            return config;
        }

        @Bean
        public RedisStandaloneConfiguration localRedisConfig() {
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
            config.setHostName(host);
            config.setPassword(RedisPassword.of(password));
            config.setPort(port);
            config.setDatabase(database);
            return config;
        }
    }


    @Configuration
    public static class DefaultRedisConfig {
        @Value("${spring.redis.host:127.0.0.1}")
        private String host;
        @Value("${spring.redis.port:6379}")
        private Integer port;
        @Value("${spring.redis.password:}")
        private String password;
        @Value("${spring.redis.database:0}")
        private Integer database;

        @Value("${spring.redis.lettuce.pool.max-active:8}")
        private Integer maxActive;
        @Value("${spring.redis.lettuce.pool.max-idle:8}")
        private Integer maxIdle;
        @Value("${spring.redis.lettuce.pool.max-wait:-1}")
        private Long maxWait;
        @Value("${spring.redis.lettuce.pool.min-idle:0}")
        private Integer minIdle;

        @Bean
        public GenericObjectPoolConfig defaultPoolConfig() {
            GenericObjectPoolConfig config = new GenericObjectPoolConfig();
            config.setMaxTotal(maxActive);
            config.setMaxIdle(maxIdle);
            config.setMinIdle(minIdle);
            config.setMaxWaitMillis(maxWait);
            return config;
        }

        @Bean
        public RedisStandaloneConfiguration defaultRedisConfig() {
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
            config.setHostName(host);
            config.setPassword(RedisPassword.of(password));
            config.setPort(port);
            config.setDatabase(database);
            return config;
        }
    }
}

测试类如下，简单的演示下两个template的读写

@SpringBootApplication
public class Application {

    public Application(RedisTemplate<String, String> localRedisTemplate, RedisTemplate<String, String>
            defaultRedisTemplate)
            throws InterruptedException {
        // 10s的有效时间
        localRedisTemplate.delete("key");
        localRedisTemplate.opsForValue().set("key", "value", 100, TimeUnit.MILLISECONDS);
        String ans = localRedisTemplate.opsForValue().get("key");
        System.out.println("value".equals(ans));
        TimeUnit.MILLISECONDS.sleep(200);
        ans = localRedisTemplate.opsForValue().get("key");
        System.out.println("value".equals(ans) + " >> false ans should be null! ans=[" + ans + "]");


        defaultRedisTemplate.opsForValue().set("key", "value", 100, TimeUnit.MILLISECONDS);
        ans = defaultRedisTemplate.opsForValue().get("key");
        System.out.println(ans);
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

上面的代码执行演示如下

showcase

上面的演示为动图，抓一下重点：

  • 注意 localRedisTemplate, defaultRedisTemplate 两个对象不相同（看debug窗口后面的@xxx)
  • 同样两个RedisTemplate的ConnectionFactory也是两个不同的实例（即分别对应前面配置类中的两个Factory)
  • 执行后输出的结果正如我们预期的redis操作
    • 塞值，马上取出没问题
    • 失效后，再查询，返回null
  • 最后输出异常日志，提示如下
Description:

Parameter 0 of method redisTemplate in org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration required a single bean, but 2 were found:
	- defaultLettuceConnectionFactory: defined by method 'defaultLettuceConnectionFactory' in class path resource [com/git/hui/boot/redis/config/RedisAutoConfig.class]
	- localLettuceConnectionFactory: defined by method 'localLettuceConnectionFactory' in class path resource [com/git/hui/boot/redis/config/RedisAutoConfig.class]


Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

上面表示说有多个ConnectionFactory存在，然后创建默认的RedisTemplate就不知道该选择哪一个了，有两种方法

方法一：指定默认的ConnectionFactory

借助@Primary来指定默认的连接工厂，然后在使用工程的时候，通过@Qualifier注解来显示指定，我需要的工厂是哪个（主要是localRedisTemplate这个bean的定义，如果不加，则会根据defaultLettuceConnectionFactory这个实例来创建Redis连接了）

@Bean
@Primary
public LettuceConnectionFactory defaultLettuceConnectionFactory(RedisStandaloneConfiguration defaultRedisConfig,
        GenericObjectPoolConfig defaultPoolConfig) {
    // ...
}

@Bean
public RedisTemplate<String, String> defaultRedisTemplate(
        @Qualifier("defaultLettuceConnectionFactory") LettuceConnectionFactory defaultLettuceConnectionFactory) {
    // ....
}

@Bean
@ConditionalOnBean(name = "localRedisConfig")
public LettuceConnectionFactory localLettuceConnectionFactory(RedisStandaloneConfiguration localRedisConfig,
        GenericObjectPoolConfig localPoolConfig) {
    // ...
}

@Bean
@ConditionalOnBean(name = "localLettuceConnectionFactory")
public RedisTemplate<String, String> localRedisTemplate(
        @Qualifier("localLettuceConnectionFactory") LettuceConnectionFactory localLettuceConnectionFactory) {
    // ...
}

方法二：忽略默认的自动配置类

既然提示的是org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration类加载bean冲突，那么就不加载这个配置即可

@SpringBootApplication
@EnableAutoConfiguration(exclude = {RedisAutoConfiguration.class, RedisReactiveAutoConfiguration.class})
public class Application {
  // ...
}

II. 其他

0. 项目

1. 一灰灰Blog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

2. 声明

尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

3. 扫描关注

一灰灰blog

QrCode

知识星球

goals

转载于:https://my.oschina.net/u/566591/blog/2254399

weixin_33757911
关注
springboot2.2 集成redis哨兵
scanklm的专栏
06-29 977
springboot版本2.2.0.RELEASE jedis版本 3.1.0 一、pom依赖： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.1.0</version> </dependency> <dependency> ...
Springboot配置RedisTemplate
qq_45860901的博客
08-10 3552
Springboot配置RedisTemplate
springboot-redis配置
weixin_44315786的博客
09-21 541
redis的配置使用
SpringBoot整合Redis--RedisTemplate
weixin_54345563的博客
04-03 2323
SpringBoot整合Redis--RedisTemplate快速上手
SpringBoot之RedisTemplate基本配置
最新发布
weixin_45195665的博客
10-16 525
SpringBoot默认RedisTemplate修改配置，以及实现密码加解密
Redis的SpringBoot配置(RedisTemplate配置)
kimi
01-13 967
Redis的SpringBoot配置(RedisTemplate配置)
SpringBoot课程-Redis.pdf
11-20
4. **高级特性**：除了基本的CRUD操作外，SpringBoot还支持Redis的一些高级特性，比如事务管理、过期策略等。 5. **缓存管理**：可以使用SpringBoot的缓存注解（如`@Cacheable`、`@CachePut`和`@CacheEvict`）来...
基于springboot和redis实现单点登录
08-25
基于SpringBoot和Redis实现单点登录是当前热门的技术栈之一，本文将详细介绍如何使用SpringBoot和Redis实现单点登录。 单点登录的优点 1. 提高用户体验：用户只需要登录一次即可访问所有相关的应用系统，提高了...
SpringBoot集成Redis
02-26
配置完成后，SpringBoot会自动创建RedisTemplate和StringRedisTemplate实例，它们提供了基本的Redis操作接口。我们可以通过@Autowired来注入这两个模板，进行数据的存取。例如，使用StringRedisTemplate保存键值对：...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件中添加Spring Data Redis和...
Springboot 整合redis配置类和封装redis服务
洛阳泰山的博客
11-19 1325
spring-boot-starter-data-redis是Spring Boot提供的一个用于集成Redis数据库的启动器（starter）。该启动器提供了与Redis相关的依赖管理、自动配置和常用功能，使得在Spring Boot应用中使用Redis变得更加简单和方便。
玩转 SpringBoot 2.x 之 RedisTemplate 操作
12-22
前言 Spring 专门提供了进行 Redis 操作的抽象 RedisTemplate，底层依然使用 Jedis 或 lettuce。SpringBoot 2 默认使用 lettuce。 Redis 安装 请参考：带你学 Redis：Redis安装（二） 代码案例 引入 spring-boot-starter-data-redis 和 commons-pool2 依赖，具体代码如下： org.springframework.boot spring-boot-starter-data-redis org.apache.commons commons-pool2 然后在
SpringBoot：RedisTemplate配置与使用
拒绝熬夜啊的博客
11-05 7377
SpringBoot：RedisTemplate配置与使用 1.依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <depen
SpringBoot集成Redis结合RedisTemplate操作
SmallCat0912的博客
12-26 3702
本文实现了在SpringBoot中集成Redis，使用RedisTemplate对象操作并编写了一些常用方法的工具类。
redis----Springboot+RedisTemplate（SpringBoot操作redis）
weixin_58419099的博客
06-08 404
1)创建一个springBoot的框架的项目，并加上一个依赖。3）使用redisTemplate来访问redis服务器。2.springboot操作redis,关于对象的操作。1.SpringBoot操作redis。可以创建一个Controller的类。2）添加配置，在yml文件中加入。3）从redis中得到对象。2）redis保存对象。1）首先添加一些配置。
SpringBoot项目集成Redis
Zeng_1997的博客
09-18 262
1、redis安装： windows安装： 下载mis文件安装，修改文件redis文件夹下的redis.windows-service.conf 设置redis账号密码 启动redis，cd到redis安装目录，执行redis-cli Linux安装： 1.获取redis资源 　　wget http://download.redis.io/releases/redis-4.0.8.tar.gz 2.解压 　　tar xz
SpringBoot集成Redis之RedisTemplate
2202_75317512的博客
09-27 954
​#================================redis单机版================================redis-server /myredis/redis7.conf #开启redis服务 必须加载配置文件​redis-cli -a 123456 -p 6379 #开启客户端运行启动类--->访问http://localhost:7777/swagger-ui.html,端口改为自己设置的server.port访问。
Redis入门 - 数据类型：5种基础数据类型详解
Ch3nnn的博客
12-18 1516
Redis所有的key（键）都是字符串。我们在谈基础数据结构时，讨论的是存储值的数据类型，主要包括常见的5种数据类型，分别是：String、List、Set、Zset、Hash Redis入门 - 数据类型：5种基础数据类型详解 Redis数据结构简介 基础数据结构详解 String字符串 List列表 Set集合 Hash散列 Zset有序集合 参考文章 ¶ Redis数据结构简介 Redis基础文章非常多，关于基础数据结构类型，我推荐你先看...
SpringBoot: RedisTemplate使用说明
amadeus_liu2的博客
07-19 614
boot
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值