redis实战spring-boot-starter-data-redis

SpringBoot集成Redis环境搭建及配置详解_springboot redis 配置-CSDN博客

如何使用Spring Boot框架整合Redis：超详细案例教程_spring-boot-starter-data-redis-CSDN博客

https://blog.csdn.net/weixin_44411039/article/details/133578724

连接池选择及Jedis连接池参数配置建议_分布式缓存服务 DCS

官网 Drivers :: Spring Data Redis

1 总结

1：默认整合了两种连接池，lettuce 和 jedis ，默认使用 lettuce连接池（因为支持的功能多）

2：如果配置了自定义的RedisConnectionFactory ，Spring Boot就不会自动配置 RedisConnectionFactory

2：不配置序列化器，我们是无法看懂的

2 pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        <!--    <version>2.5.1</version>-->
        </dependency>
         <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
          <!--  <version>2.9.0</version>-->
        </dependency>

配置jedis连接池时用

      <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

3 简单使用(单机版)

配置文件

spring:
  application:
    name: redis
  redis:
    port: 6379
    database: 0
    # host: 192.168.135.10
    host: 127.0.0.1
    jedis:
      pool:
        max-active: 300
        max-idle: 300
        min-idle: 100
        max-wait: 5s
    lettuce:
      pool:
        max-active: 300
        max-idle: 300
        min-idle: 100
        max-wait: 5s
      shutdown-timeout: 100ms

直接使用，设置值

    @Autowired
    RedisTemplate redisTemplate;
    @Test
    void contextLoads1() {
        //設置字符串 新值
        redisTemplate.opsForValue().set("ok","测试ok1");
        String ok = (String)redisTemplate.opsForValue().get("ok");
        System.out.println(ok);
    }

因为未配置序列化器

默认加载哪个连接池

结论：不自定义连接池情况下，默认只会加载lettuce连接池

1：当我们配置文件配置了lettuce时，会加在配置单连接池中。

配置文件不会因为你配置 jedis 默认使用jedis连接池。

序列化器


import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.beans.factory.annotation.Autowired;
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.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisTemplateConfig {
    /**
     * 可以注入方式设置连接
     */
/*    @Autowired
    private RedisConnectionFactory factory;*/

    /**
     * RedisTemplate配置 改成json序列化模式用keys方法可取到值 否则取不到
     *
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局开启AutoType，不建议使用
        // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式，小范围指定白名单
        ParserConfig.getGlobalInstance().addAccept("com.demo.");
        // 设置值（value）的序列化采用FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.setDefaultSerializer(fastJsonRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
    /**
     * 可以删除
     */
    @Bean
    public ValueOperations valueOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForValue();
    }
    /**
     * 可以删除
     */
    @Bean
    public ListOperations listOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForList();
    }
    /**
     * 可以删除
     */
    @Bean
    public HashOperations hashOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForHash();
    }
}

方式二

测试成功

4 自定义LettuceConnectionFactory

1：场景：配置文件中用户，密码是加密的，需要解密后设置到连接池中。

2：可以发现自定义配置参数会覆盖配置文件的配置参数

import com.alibaba.fastjson.parser.ParserConfig;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;



@Configuration  // 配置类
public class RedisConfig  {

    /**
     *  配置 Redis 连接工厂
     *  意义: LettuceConnectionFactory 是连接 Redis 服务器的入口，它使用了 Lettuce 客户端，并且配置了连接池来提高性能和资源管理
     * @return
     */
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        // 配置 Redis 服务器的连接信息 可以读取配置文件获取
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName("localhost");
        redisStandaloneConfiguration.setPort(6379);
        // redisStandaloneConfiguration.setPassword("password"); // 取消注释以设置密码
        // 配置连接池
        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(10);       // 连接池中的最大连接数
        poolConfig.setMaxIdle(5);         // 连接池中的最大空闲连接数
        poolConfig.setMinIdle(1);         // 连接池中的最小空闲连接数
        poolConfig.setMaxWaitMillis(2000); // 连接池获取连接的最大等待时间
        // 创建一个带有连接池配置的 Lettuce 客户端配置
        LettucePoolingClientConfiguration lettucePoolingClientConfiguration =
            LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig)
                .build();
        // 返回带有连接池配置的 Redis 连接工厂
        return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
    }



    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        /*    2.设置连接工厂: 使用前面定义的 LettuceConnectionFactory。
            3.设置序列化器: 设置键和值的序列化器，这里使用 StringRedisSerializer 来将键和值序列化为字符串。
         */
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局开启AutoType，不建议使用
        // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式，小范围指定白名单
        ParserConfig.getGlobalInstance().addAccept("com.demo.");
        // 设置值（value）的序列化采用FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.setDefaultSerializer(fastJsonRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }


}

最终加载的是代码中自定义配置的连接池参数，而不是配置文件中配置。

5 自定义JedisConnectionFactory

1:配置了Jedis连接池后，用的就是Jedis了。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisConnectionConfig {
    @Autowired
   private Environment env;
    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        Integer port = Integer.valueOf(env.getProperty("spring.redis.port"));
        String host = env.getProperty("spring.redis.host");
        String password = env.getProperty("spring.redis.password");
        Integer database = Integer.valueOf(env.getProperty("spring.redis.database"));
        Integer maxActive = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.max-active"));
        Integer maxIdle = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.max-idle"));
        Integer minIdle = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.min-idle"));
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(maxIdle);
        //最大连接数
        poolConfig.setMaxTotal(maxActive);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(20000);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestOnBorrow(true);
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("server", 6379);
        config.setPort(port);
        config.setDatabase(database);
        config.setHostName(host);
        if (null != password) {
            config.setPassword(password);
        }
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(config);
        jedisConnectionFactory.setPoolConfig(poolConfig);
        return jedisConnectionFactory;
    }
}