RedisTemplate

lettuce

pom.xml ```xml org.springframework.boot spring-boot-starter-data-redis

org.apache.commons commons-pool2 - application.ymlyaml spring: redis: host: 127.0.0.1 port: 6379 # Redis 服务器密码，默认为空。生产中，一定要设置 Redis 密码！ password: # Redis 数据库号，默认为 0 。 database: 0 # Redis 连接超时时间，默认单位：毫秒。 timeout: 1S # 可以用 lettuce/jedis，如果要用后者需要排除lettuce依赖 lettuce: pool: # 连接池最大连接数，默认为 8 。使用负数表示没有限制。 max-active: 16 # 默认连接数最小空闲的连接数，默认为 8 。使用负数表示没有限制。 max-idle: 10 # 默认连接池最小空闲的连接数，默认为 0 。允许设置 0 和正数。 min-idle: 1 # 连接池最大阻塞等待时间，单位：毫秒。默认为 -1 ，表示不限制。 max-wait: 1000

---


<a name="WptXc"></a>
## jedis

- pom.xml

xml org.springframework.boot spring-boot-starter-data-redis io.lettuce lettuce-core

redis.clients jedis


- application.yml
```yaml
spring:
  # 对应 RedisProperties 类
  redis:
    host: 127.0.0.1
    port: 6379
    password: # Redis 服务器密码，默认为空。生产中，一定要设置 Redis 密码！
    database: 0 # Redis 数据库号，默认为 0 。
    timeout: 1000 # Redis 连接超时时间，单位：毫秒。
    # 对应 RedisProperties.Jedis 内部类
    jedis:
      pool:
        max-active: 16 # 连接池最大连接数，默认为 8 。使用负数表示没有限制。
        max-idle: 10 # 默认连接数最小空闲的连接数，默认为 8 。使用负数表示没有限制。
        min-idle: 1 # 默认连接池最小空闲的连接数，默认为 0 。允许设置 0 和 正数。
        max-wait: 1000 # 连接池最大阻塞等待时间，单位：毫秒。默认为 -1 ，表示不限制。

整体配置

先补充个 StringRedisTemplate 和一个 String 的序列化器 ```java @Configuration public class RedisConfig {

/* Redis连接工厂 / @Autowired private RedisConnectionFactory redisConnectionFactory;

   /**
 *  <h2>string 模板</h2>
 *
 * @return {@link org.springframework.data.redis.core.StringRedisTemplate}
 */
@Bean
public StringRedisTemplate stringRedisTemplate() {
    StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
    stringRedisTemplate.setConnectionFactory(redisConnectionFactory);
    return stringRedisTemplate;
}
/**
 *  <h2> String 序列化器 </h2>
 *
 * @return {@link org.springframework.data.redis.core.StringRedisTemplate}
 */
@Bean
public StringRedisSerializer stringRedisSerializer() {
    return new StringRedisSerializer();
}

}


- 然后补充个生成模板的私有方法
```java
    /**
     * 根据条件创建一个 RedisTemplate
     *
     * @param stringRedisSerializer       string 序列化器
     * @param redisSerializer             json 序列化器
     * @param isEnableTransactionSupport  是否开启事务
     * @return {@link org.springframework.data.redis.core.RedisTemplate}
     */
    private RedisTemplate<String, Object> _createRedisTemplate(StringRedisSerializer stringRedisSerializer,
                                                               RedisSerializer redisSerializer,
                                                               boolean... isEnableTransactionSupport) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        ////////////////////////////////////////////////////
        //      默认使用的是 JdkSerializationRedisSerializer
        ////////////////////////////////////////////////////
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用 redisSerializer
        template.setValueSerializer(redisSerializer);
        // hash的value序列化方式采用 redisSerializer
        template.setHashValueSerializer(redisSerializer);
        // 是否开启事务
        if (isEnableTransactionSupport.length == 0) {
            isEnableTransactionSupport = new boolean[]{false};
        }
        template.setEnableTransactionSupport(isEnableTransactionSupport[0]);
        template.afterPropertiesSet();
        return template;
    }

模板

jackson 模板

定义下 ObjectMapper 和 jackson 序列化器
然后生成 jackson 的 redisTemplate


    /**
     * <h2> 默认用的 jackson 序列化模板 </h2>
     *
     * @return {@link org.springframework.data.redis.core.RedisTemplate}
     */
    @Bean
    public RedisTemplate<String, Object> jacksonRedisTemplate() {
        return _createRedisTemplate(stringRedisSerializer(), jackson2JsonRedisSerializer());
    }
    /**
     * <h2>jackson 序列化用的 objectMapper </h2>
     *
     * @return {@link com.fasterxml.jackson.databind.ObjectMapper}
     */
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        // 支持任意对象的 json 序列化和反序列化
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 过期，源码可知使用 activateDefaultTyping(getPolymorphicTypeValidator(), applicability, includeAs) 代替
        // objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        // 属性全包括
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        // 取消默认转换为timestamp形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 忽略空 bean 转 json 的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        // 所有的日期格式都统一为 yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        // 忽略在 json 字符串中存在，对应 bean 不存在字段的情况，避免错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        return objectMapper;
    }
    /**
     * <h2> jackson redis 序列化器 </h2>
     *
     * @return {@link org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer}
     */
    @Bean
    public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper());
        return jackson2JsonRedisSerializer;
    }

fastJson 模板

定义下 fastJson 的序列化器 ```java /**

使用 fastjson 作为 redis序列化器 *

@param / public class FastJson2JsonRedisSerializer implements RedisSerializer { /*

字符集 */ private final Charset charset;

/**

指定class */ private Class tClass;

static {

//如果遇到反序列化autoType is not support错误，请添加并修改一下包名到bean文件路径
// ParserConfig.getGlobalInstance().addAccept("com.xxxxx.xxx");
// 或者直接全局开启
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);

}

/**
 * 默认字符集为 UTF-8
 */
public FastJson2JsonRedisSerializer() {
    this(StandardCharsets.UTF_8);
}
public FastJson2JsonRedisSerializer(Charset charset) {
    Assert.notNull(charset, "charset must be not null! ");
    this.charset = charset;
}
/**
 *  <h2> 序列化设置 </h2>
 *
 * @param object    被序列化的内容
 * @return byte[]
 * @throws SerializationException
 */
@Override
public byte[] serialize(T object) throws SerializationException {
    if (object == null) {
        return new byte[0];
    }
    if (object instanceof String) {
        return object.toString().getBytes(charset);
    } else {
        // 使用 fastJson 做序列化
        return JSON.toJSONString(object, SerializerFeature.WriteClassName).getBytes(charset);
    }
}
/**
 * <h2> 反序列化设置 </h2>
 *
 * @param bytes     反序列化数组
 * @return  {@link T}        
 * @throws SerializationException
 */
@Override
public T deserialize(byte[] bytes) throws SerializationException {
    if (bytes == null || bytes.length == 0) {
        return null;
    }
    String str = new String(bytes, charset);
    return JSON.parseObject(str, tClass);
}

}


- 生成 `fastJson` 的 `redisTemplate`
```java
     /**
     * <h2> fastJson redis 序列化器 </h2>
     *
     * @return {@link com.example.redisdemo.config.FastJson2JsonRedisSerializer}
     */
    @Bean
    public FastJson2JsonRedisSerializer<Object> fastJson2JsonRedisSerializer() {
        return new FastJson2JsonRedisSerializer<>();
    }
     /**
     * <h2>用 fastJson 序列化的 redisTemplate</h2>
     *
     * @return {@link org.springframework.data.redis.core.RedisTemplate}
     */
    @Bean
    public RedisTemplate<String, Object> fastJsonRedisTemplate()
    {
        return _createRedisTemplate(stringRedisSerializer(), fastJson2JsonRedisSerializer());
    }

如何使用

注入的时候指定下 bean 名称即可

注意点

LocalDateTime

需要加上序列化、反序列化器

@JsonDeserialize(using = LocalDateTimeDeserializer.class)
@JsonSerialize(using = LocalDateTimeSerializer.class)
private LocalDateTime localDateTime;

joda-time 应该也差不多吧

新版后端

SpringBoot 整合 Redis