工作日记2017.08.19 spring-data-redis使用

本文介绍如何使用JedisConnectionFactory配置RedisTemplate,并探讨了不同序列化方式的影响。同时,推荐使用Redis内置的数据结构来提高效率。

JedisConnectionFactory是连接工厂,通过配置单台服务器或连接池(pool)的方式获取redis服务器的连接

@Primary
    @Bean(name="redisTemplate")
    public RedisTemplate redisTemplate(JedisConnectionFactory factory) {
        RedisTemplate rt = new RedisTemplate();
        FastJsonSerializer fastJsonSerializer = new FastJsonSerializer();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        rt.setConnectionFactory(factory);
        rt.setKeySerializer(stringRedisSerializer);
        rt.setValueSerializer(fastJsonSerializer);
        rt.setHashKeySerializer(fastJsonSerializer);
        rt.afterPropertiesSet();
        return rt;
    }

RedisTemplate快速完成基本的crud操作

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware

StringRedisTemplate提供了最常用的String实现

public class StringRedisTemplate extends RedisTemplate<String, String>

注意:
不要使用泛型JAVA集合,如RedisTemplate<Object, Collection<?>>
因为,这样等于让JVM把Collection<?>序列化为字节数组,已value的方式保存在redis中。这种方式,存在大量的序列化反序列化操作,并且每次操作集合,都要先获得一个完成的集合(即集合的所有元素)。
建议,使用redis提供的集合类型,如List,Set,ZSet(Sorted set)和Map。

    private ListOperations<K, V> listOps;
    private SetOperations<K, V> setOps;
    private ZSetOperations<K, V> zSetOps;
    private GeoOperations<K, V> geoOps;
    private HyperLogLogOperations<K, V> hllOps;

opsForXXX 和 boundXXXOps 的区别
opsForXXX 获得一个operator,但是没有指定key,在一个连接(事务)内操作多个key和其对应的value。如:

public ValueOperations<K, V> opsForValue() {
        if (valueOps == null) {
            valueOps = new DefaultValueOperations<K, V>(this);
        }
        return valueOps;
    }

boundXXXOps 获得一个指定了操作对象(key)的operator,在一个连接内只能操作这个key的value。如:

public BoundValueOperations<K, V> boundValueOps(K key) {
        return new DefaultBoundValueOperations<K, V>(key, this);
    }
<think>我们正在使用SpringData Redis2.1.2.RELEASE版本。在这个版本中,配置RedisTemplate的连接池需要通过配置LettuceConnectionFactory(因为SpringBoot2.x默认使用Lettuce作为Redis客户端)来实现。连接池配置通常通过设置LettuceConnectionFactory的LettucePoolingClientConfiguration来完成。 步骤: 1.引入必要的依赖(确保已经包含了spring-boot-starter-data-redis和commons-pool2)。2.创建一个配置类(例如RedisConfig),在其中定义RedisConnectionFactorybean,并配置连接池。3.RedisConnectionFactory中设置连接池参数(如最大连接数、最小空闲连接数等)。 4.然后,使用这个RedisConnectionFactory来配置RedisTemplate。 根据引用[3]和[4],我们需要引入spring-boot-starter-data-redis和commons-pool2依赖。由于我们使用的是SpringData Redis2.1.2.RELEASE(对应SpringBoot2.1.x版本),所以commons-pool2的版本需要兼容。 下面是一个配置示例:```javaimportorg.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration; importorg.springframework.data.redis.connection.RedisConnectionFactory; importorg.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration; importorg.springframework.data.redis.core.RedisTemplate; importorg.springframework.data.redis.serializer.StringRedisSerializer; importio.lettuce.core.ClientOptions;import io.lettuce.core.SocketOptions;import io.lettuce.core.resource.ClientResources;import org.apache.commons.pool2.impl.GenericObjectPoolConfig;@Configurationpublicclass RedisConfig {@BeanpublicRedisConnectionFactory redisConnectionFactory() {//配置连接池GenericObjectPoolConfigpoolConfig= newGenericObjectPoolConfig();poolConfig.setMaxTotal(8);//最大连接数poolConfig.setMaxIdle(8); //最大空闲连接数poolConfig.setMinIdle(0);//最小空闲连接数//其他连接池配置...//创建Lettuce连接池配置LettucePoolingClientConfiguration clientConfig =LettucePoolingClientConfiguration.builder().poolConfig(poolConfig).clientOptions(ClientOptions.builder().socketOptions(SocketOptions.builder().connectTimeout(Duration.ofSeconds(10))//连接超时时间.build()).build()).build();//配置Redis连接信息(这里假设使用默认的localhost:6379,无密码)LettuceConnectionFactory factory= newLettuceConnectionFactory();factory.setPoolConfig(poolConfig); //设置连接池配置factory.setClientConfiguration(clientConfig);//设置客户端配置factory.afterPropertiesSet(); //初始化returnfactory;}@BeanpublicRedisTemplate<String,Object>redisTemplate(RedisConnectionFactoryredisConnectionFactory){RedisTemplate<String,Object>redisTemplate= newRedisTemplate<>();redisTemplate.setConnectionFactory(redisConnectionFactory);//设置key的序列化器redisTemplate.setKeySerializer(new StringRedisSerializer());//设置value的序列化器,这里使用Jackson2JsonRedisSerializer//注意:需要为Object.class配置Jackson2JsonRedisSerializer,并且确保你的类可以被序列化//但为了简单,这里先使用String序列化器,实际使用中可以根据需要配置redisTemplate.setValueSerializer(newStringRedisSerializer());//设置hash key和value的序列化器redisTemplate.setHashKeySerializer(new StringRedisSerializer());redisTemplate.setHashValueSerializer(new StringRedisSerializer());returnredisTemplate;} }``` 注意:-上述代码中,我们通过`LettucePoolingClientConfiguration`来配置连接池。但是,在SpringDataRedis2.1.2中,`LettuceConnectionFactory`有一个接受`LettuceClientConfiguration`的构造方法,我们也可以使用`LettucePoolingClientConfiguration`来配置连接池。-但是,实际上在Spring DataRedis2.1.2中,更常见的做法是直接通过`LettuceConnectionFactory`的`setPoolConfig`方法设置连接池配置,因为`LettuceConnectionFactory`内部会使用这个配置来创建连接池。 -另外,我们还可以通过`application.properties`或`application.yml`文件来配置连接池参数,这样更加方便。例如: 在application.properties中配置: ```propertiesspring.redis.lettuce.pool.enabled=truespring.redis.lettuce.pool.max-idle=8spring.redis.lettuce.pool.min-idle=0spring.redis.lettuce.pool.max-active=8spring.redis.lettuce.pool.max-wait=-1ms```然后,我们可以简化配置类,只需要创建一个RedisTemplate即可,因为Spring Boot会自动配置RedisConnectionFactory。但是,根据用户的问题,他要求配置RedisTemplate的连接池,并且没有提到使用配置文件,所以我们使用代码配置的方式。另外,引用[2]中展示了自定义RedisTemplate的序列化方式,我们在上面的RedisTemplate中也进行了设置。但是,请注意,上面的配置中我们使用了String序列化器,如果希望使用JSON序列化,可以像引用[2]那样使用Jackson2JsonRedisSerializer。修改序列化为JSON的方式:```javaimportorg.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;import com.fasterxml.jackson.databind.ObjectMapper;//在RedisConfig类中@BeanpublicRedisTemplate<String,Object>redisTemplate(RedisConnectionFactoryredisConnectionFactory){RedisTemplate<String,Object>redisTemplate= newRedisTemplate<>();redisTemplate.setConnectionFactory(redisConnectionFactory);//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值Jackson2JsonRedisSerializer<Object> serializer= newJackson2JsonRedisSerializer<>(Object.class);ObjectMapperobjectMapper= newObjectMapper();//配置ObjectMapper,根据需要设置serializer.setObjectMapper(objectMapper);redisTemplate.setKeySerializer(newStringRedisSerializer());redisTemplate.setValueSerializer(serializer);redisTemplate.setHashKeySerializer(newStringRedisSerializer());redisTemplate.setHashValueSerializer(serializer);redisTemplate.afterPropertiesSet();return redisTemplate;} ```这样,我们就配置了一个使用连接池的RedisTemplate,并且使用了JSON序列化。总结步骤: 1.配置RedisConnectionFactory,设置连接池参数。2.配置RedisTemplate,设置序列化方式。注意:在SpringBoot2.x中,默认的Redis客户端是Lettuce,所以我们使用LettuceConnectionFactory。如果使用Jedis,则需要配置JedisConnectionFactory,但Spring Boot2.x推荐使用Lettuce。 最后,确保在pom.xml中引入了必要的依赖(如引用[3]和[4]所示):```xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId> </dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId> </dependency>``` 因为Lettuce需要commons-pool2来支持连接池。 这样,我们就完成了在Spring DataRedis2.1.2.RELEASE中配置RedisTemplate连接池的任务。§§相关问题§§1.如何在SpringBoot中通过配置文件配置Redis连接池参数? 2.使用Lettuce和Jedis连接Redis有什么区别? 3.如何为RedisTemplate配置不同的序列化方式以适应不同的数据类型?</think>### 在 Spring Data Redis 2.1.2.RELEASE 中配置 RedisTemplate 连接池 以下是完整的配置步骤(基于 Lettuce 客户端): #### 1. 添加依赖(pom.xml) ```xml <dependencies> <!-- Spring Data Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.1.2.RELEASE</version> </dependency> <!-- 连接池依赖 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.6.2</version> <!-- 兼容版本 --> </dependency> </dependencies> ``` [^3][^4] #### 2. 配置连接池(RedisConfig.java) ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; 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; import io.lettuce.core.ClientOptions; import io.lettuce.core.SocketOptions; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import java.time.Duration; @Configuration public class RedisConfig { // 连接池配置 @Bean public GenericObjectPoolConfig<Object> redisPoolConfig() { GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>(); poolConfig.setMaxTotal(8); // 最大连接数 poolConfig.setMaxIdle(8); // 最大空闲连接 poolConfig.setMinIdle(0); // 最小空闲连接 poolConfig.setMaxWait(Duration.ofMillis(1000)); // 等待时间 poolConfig.setTestOnBorrow(true); // 借用连接时测试 return poolConfig; } // Redis连接工厂(使用连接池) @Bean public RedisConnectionFactory redisConnectionFactory() { LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder() .poolConfig(redisPoolConfig()) .clientOptions(ClientOptions.builder() .socketOptions(SocketOptions.builder() .connectTimeout(Duration.ofSeconds(2)).build()) .build()) .build(); LettuceConnectionFactory factory = new LettuceConnectionFactory(); factory.setHostName("localhost"); factory.setPort(6379); factory.setPassword(""); // 如有密码需设置 factory.setClientConfiguration(clientConfig); factory.afterPropertiesSet(); // 初始化连接池 return factory; } // 配置RedisTemplate @Bean public RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory()); // 序列化配置 template.setKeySerializer(new StringRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); template.afterPropertiesSet(); return template; } } ``` [^2] #### 3. 配置文件(application.properties) ```properties # 连接池参数 spring.redis.lettuce.pool.enabled=true spring.redis.lettuce.pool.max-idle=8 spring.redis.lettuce.pool.min-idle=0 spring.redis.lettuce.pool.max-active=8 spring.redis.lettuce.pool.max-wait=1000ms # 基础配置 spring.redis.host=localhost spring.redis.port=6379 spring.redis.timeout=2000ms ``` ### 关键配置说明: 1. **连接池核心参数**: - `maxTotal`:最大连接数(默认8) - `maxIdle`:最大空闲连接(建议与maxTotal相同) - `minIdle`:最小空闲连接(防止突发流量) - `maxWaitMillis`:获取连接最长等待时间 2. **Lettuce 特性**: - 异步非阻塞IO - 自动重连机制 - 支持响应式编程 3. **序列化建议**: - Key 使用 `StringRedisSerializer` - Value 推荐 `Jackson2JsonRedisSerializer` - 避免使用 JdkSerializationRedisSerializer(有版本兼容问题) > **注意**:Spring Boot 2.1.x 默认使用 Lettuce 客户端,连接池需显式开启。生产环境建议配置 `testOnBorrow` 和 `testWhileIdle` 检测连接有效性[^1]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值