SpringBoot中配置redis的序列化方式实战

springboot项目中使用redis是很常见的业务场景，今天我们分享一下boot项目中，redis的连接配置、序列化等。

1、引入jar

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.6.RELEASE</version>
	<relativePath /> 
</parent>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-redis</artifactId>
	<version>2.5.5</version> 
</dependency>
 

2、yml配置文件：

spring:
  config:
      redis:
         nodes: 192.0.9.101:8001,192.0.8.101:8001
         database: 0. # 选择的数据库
         password: 123456。  # 密码
         timeout: 30000  # 连接超时时长（毫秒）
         maxactive: 2000  # 连接池最大连接数（使用负值表示没有限制）
         maxwait: -1      # 连接池最大阻塞等待时间（使用负值表示没有限制）
         maxidle: 10      # 连接池中的最大空闲连接
         minidle: 5       # 连接池中的最小空闲连接
         maxRedirects: 3
         periodicRefreshMillis: 60000 #按照周期刷新拓扑
         timeoutOptionsMillis: 20000 #redis命令超时，使用新的拓扑信息重新建立连接

3、项目中配置序列化：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

@Configuration
@Slf4j
@ConfigurationProperties(prefix = "spring.config.redis")
public class CommonRedisConfig extends BaseCommonRedisConfig {

    @Bean("redisTemplate")
    public RedisTemplate getDefaultRedisTemplate() {
        RedisTemplate redisTemplate = new RedisTemplate();
        setSerializer(redisTemplate);//序列化配置
        redisTemplate.setConnectionFactory(connectionFactory());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean("stringRedisTemplate")
    public StringRedisTemplate getDefaultStringRedisTemplate() {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(connectionFactory());
        stringRedisTemplate.afterPropertiesSet();
        return stringRedisTemplate;
    }

    /**
     * redisTemplate 序列化配置
     * @param redisTemplate
     */
    private void setSerializer(RedisTemplate redisTemplate) {
        redisTemplate.setKeySerializer(new StringRedisSerializer()); //key 采用的String 的序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());//hashde key 也采用String的序列化方式
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer());//hash 的 value序列化方式采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer());//value 序列化方式采用jackson
    }

    /**
     *  设置value的序列化器
     *  使用Jackson 2，将对象序列化为JSON
     * @return
     */
    @Bean
    public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        final Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(
                Object.class);
        //json转对象类，不设置默认的会将json转成hashmap
        final ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
        objectMapper.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return jackson2JsonRedisSerializer;
    }
}

 4、redis的连接配置：

import io.lettuce.core.TimeoutOptions;
import io.lettuce.core.cluster.ClusterClientOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions;
import lombok.Setter;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

@Setter
public abstract class BaseCommonRedisConfig {

    private String nodes;

    private String password;

    private int periodicRefreshMillis;

    private int timeoutOptionsMillis;

    private int timeout;

    private int maxactive;

    private int maxwait;

    private int maxidle;

    private int minidle;

    private int maxRedirects;

    /**
     * 连接redis的函数
     * @return
     */
    public RedisConnectionFactory connectionFactory() {
        // 集群redis
        RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
        List<RedisNode> nodeList = new ArrayList<>();
        String[] cNodes = nodes.split(",");
        //分割出集群节点
        for (String node : cNodes) {
            String[] hp = node.split(":");
            nodeList.add(new RedisNode(hp[0], Integer.parseInt(hp[1])));
        }
        redisConfig.setClusterNodes(nodeList);
        redisConfig.setMaxRedirects(maxRedirects);
        redisConfig.setPassword(password);

        ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                .enablePeriodicRefresh(Duration.ofMillis(periodicRefreshMillis)) //按照周期刷新拓扑
                .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑
                .build();

        ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
                //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接
                .timeoutOptions(TimeoutOptions.enabled(Duration.ofMillis(timeoutOptionsMillis)))
                .topologyRefreshOptions(topologyRefreshOptions)
                .build();

        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .clientOptions(clusterClientOptions)
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig())
                .build();
        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisConfig, clientConfig);
        factory.setPassword(password);
        factory.afterPropertiesSet();
        return factory;
    }

    /**
     * GenericObjectPoolConfig redis连接池配置
     * @return
     */
    @Bean
    public GenericObjectPoolConfig genericObjectPoolConfig() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(maxactive);
        genericObjectPoolConfig.setMaxIdle(maxidle);
        genericObjectPoolConfig.setMaxWaitMillis(maxwait);
        genericObjectPoolConfig.setMinIdle(minidle);
        return genericObjectPoolConfig;
    }
}

5、到此项目中redis的配置基本就是这些，然后你就可以写redis工具类了，为业务代码做准备。