SpringBoot 2.X Redis Jackson 序列化配置

​
​

1 摘要

Spring Data Redis 的序列化使用的是 JDK 的序列化方案，储存的为二进制数据。一般集成 Redis 时，需要自定义序列化方案，本文将给出适用于 SpringBoot 2.5+ 的 Redis Jackson 序列化方案。

​

2 核心 Maven 依赖

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson-bom.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

其中 springBoot 的版本为 2.5.1, jackson 的版本为 2.12.3, commons-pool2 的版本为 2.9.0

​

3 核心代码

3.1 序列化配置类

./demo-base-web/src/main/java/com/ljq/demo/springboot/baseweb/config/RedisConfig.java

package com.ljq.stock.alert.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
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.StringRedisSerializer;

import java.io.Serializable;

/**
 * @Description: redis 配置
 * @Author: junqiang.lu
 * @Date: 2018/10/29
 */
@Configuration
public class RedisConfig {

    /**
     * redisTemplate 序列化默认使用的jdk Serializable, 存储二进制字节码, 所以自定义序列化类
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Serializable, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Serializable, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(new LaissezFaireSubTypeValidator(),
                ObjectMapper.DefaultTyping.EVERYTHING);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

3.2 Redis 配置信息

./xx/application-dev.yml

Lettuce 版

spring:  
  redis:
    database: 1
    host: 127.0.0.1
    port: 6379
    password: 
    connect-timeout: 60s
    timeout: 120s
    lettuce:
      pool:
        max-wait: 60s
        max-active: 20
        max-idle: 10
        min-idle: 5

Jedis 版

spring:
  redis:
    database: 1
    host: 127.0.0.1
    port: 6379
    password: 
    timeout: 10000ms
    jedis:
      pool:
        max-active: 200
        max-idle: 500
        min-idle: 50
        max-wait: 100s

3.3 Redis 操作工具类

./demo-base-web/src/main/java/com/ljq/demo/springboot/baseweb/cache/RedisUtil.java

package com.ljq.demo.springboot.baseweb.cache;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @Description: redis 工具类
 * @Author: junqiang.lu
 * @Date: 2018/10/29
 */
@Component
public class RedisUtil implements Serializable {

    private static final long serialVersionUID = 894291893913244121L;

    @Autowired
    private RedisTemplate<Serializable, Object> redisTemplate;


    /**
     * 写入缓存
     * 不指定保存时间,永久保存
     *
     * @param key
     * @param value
     * @return
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 写入缓存
     * 指定保存时间,单位：秒,超时将自动删除
     *
     * @param key
     * @param value
     * @param expireTime
     * @return
     */
    public void set(String key, Object value, Long expireTime) {
        redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 判断缓存中是否有对应的 key
     *
     * @param key
     * @return
     */
    public boolean exists(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除一条记录
     *
     * @param key
     * @return
     */
    public boolean remove(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    /**
     * 批量删除
     *
     * @param keyList
     */
    public void removeBatch(List<String> keyList) {
        Set<Serializable> keys = new HashSet<>(keyList);
        if (keys.size() > 0){
            redisTemplate.delete(keys);
        }
    }

    /**
     * 向 map 集合插入一条数据
     *
     * @param key 集合 key
     * @param hashKey 元素 key
     * @param value 元素值
     */
    public void mapPut(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 向 map 集合插入多条数据
     *
     * @param key 集合 key
     * @param elementMap 元素 map 集合
     */
    public void mapPutBatch(String key, Map<String, Object> elementMap) {
        redisTemplate.opsForHash().putAll(key, elementMap);
    }

    /**
     * 从 map 集合中获取一个元素
     *
     * @param key 集合 key
     * @param hashKey 元素 key
     * @param clazz 元素值类
     * @return
     */
    public <V> V mapGet(String key, String hashKey, Class<V> clazz) {
        return (V) redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 从 map 集合中读取所有元素
     *
     * @param key 集合 key
     * @param clazz 元素值类
     * @return
     */
    public <V> List<V> mapGetAll(String key, Class<V> clazz) {
        return redisTemplate.opsForHash().values(key).stream().map(o -> (V)o).collect(Collectors.toList());
    }

    /**
     * 删除 map 集合中一个元素
     *
     * @param key 集合 key
     * @param hashKey 元素 key
     */
    public void mapRemove(String key, String hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    /**
     * 批量删除 map 集合元素
     *
     * @param key 集合 key
     * @param hashKeyList 元素 key 列表
     */
    public void mapRemoveBatch(String key, List<String> hashKeyList) {
        redisTemplate.opsForHash().delete(key, hashKeyList.toArray());
    }


}

4 Github 源码

Gtihub 源码地址 : https://github.com/Flying9001/springBootDemo

个人公众号:404Code,分享半个互联网人的技术与思考，感兴趣的可以关注.