集成 Spring data redis 笔记

摘要：本文有部分代码是抄袭的。第二个坑需要指定对象的数据类型，不然反序列化报错。第三的编辑器非常不好用。上面的配置有个缺陷，就是只能指定数据类型去缓存到。其实还可以配置一个但我持久层是。查询分页结果时，会无法反序列化。搜了半天没解决方案。

本文有部分代码是抄袭的。

1 ：引入依赖


  org.springframework.data
  spring-data-redis
  ${spring-data-redis.version}



  org.apache.commons
  commons-pool2
  ${commons-pool2.version}




  biz.paluch.redis
  lettuce
  ${lettuce.version}

/**
 * 配置缓存
 */

@EnableCaching
public class CachingConfig extends CachingConfigurerSupport {

@Resource(name = "redisTemplate")
private RedisTemplate redisTemplate;

@Override
@Bean(name = "redisCache")
public CacheManager cacheManager() {

    ///需要更快启动cacheManager就开启这个
    // manager.afterPropertiesSet();
    // ConcurrentMapCacheManager manager=new ConcurrentMapCacheManager();
    RedisCacheManager manager = new RedisCacheManager(redisTemplate);
    return manager;
}

@Override
@Bean(name = "redisKeyGen")
public KeyGenerator keyGenerator() {
    return new KeyGenerator() {
        @Override
        public Object generate(Object target, Method method, Object... objects) {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : objects) {
                sb.append(obj.toString());
            }
            return sb.toString();
        }
    };
}

}

配置redis

public class RedisConfig {

private static final Logger LOGGER = LoggerFactory.getLogger(RedisConfig.class);


private String host = "localhost";

private int port = 6379;

private String password = "redis";

private int database = 0;


/**
 * 使用这个连接池，需要commons-pool2依赖
 * lettuce其实没有必要使用连接池 https://github.com/lettuce-io/lettuce-core/wiki/Connection-Pooling
 *
 * @return
 */
@Bean(value = "lettucePool")
public LettucePool lettucePool() {
    DefaultLettucePool pool = new DefaultLettucePool();
    pool.setDatabase(0);
    pool.setHostName("localhost");
    pool.setPort(6379);
    //调用这个方法，确保连接池被初始化
    pool.afterPropertiesSet();
    return pool;
}


/**
 * 设置 redis连接工厂，通过连接池的方式来初始化工厂
 *
 * @return
 */
//@Lazy(value = false)
@Bean(name = "redisConnectionFactory")
@DependsOn(value = "lettucePool")
public RedisConnectionFactory redisConnectionFactory() {
    //Linux使用这种方式初始化工厂
    //return new LettuceConnectionFactory(new RedisSocketConfiguration("/var/run/redis.sock"));
    LettuceConnectionFactory factory = new LettuceConnectionFactory(lettucePool());
    //如果不使用连接池初始化工厂，则需要调用这个方法
    //factory.afterPropertiesSet();
    return factory;
}


/**
 * 设置redis操作模板
 *
 * @param redisConnectionFactory
 * @return
 */
@Bean(name = "redisTemplate")
@DependsOn(value = "redisConnectionFactory")
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory,
                                                   Jackson2JsonRedisSerializer jackson2JsonRedisSerializer,
                                                   StringRedisSerializer stringRedisSerializer) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);

    //设置序列化方式
    
    template.setHashKeySerializer(jackson2JsonRedisSerializer);
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.setKeySerializer(jackson2JsonRedisSerializer);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    
    template.setStringSerializer(stringRedisSerializer);

    return template;
}

}

设置序列化

public class SerializerConfig {

/**
 * 配置 jackson mapper
 * @return
 */
@Lazy(value = false)
@Bean(name = "jacksonMapper")
public ObjectMapper jacksonMapper(){
    ObjectMapper mapper=new ObjectMapper();
    //只针对非空的值进行序列化
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    // 去掉各种@JsonSerialize注解的解析
    //mapper.configure(MapperFeature.USE_ANNOTATIONS, false);

    // 将类型序列化到属性json字符串中 有的文章说需要这个才能正确反序列化
    //mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

    // 对于找不到匹配属性的时候忽略报错
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    // 不包含任何属性的bean也不报错
    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

    return mapper;
}


/**
 * 关键
 * Jackson2JsonRedisSerializer 是泛型，需要指定类型
 * 这样才能正确反序列化，不然会抛出 java.util.LinkedHashMap cannot be cast YOUR OBJECT 异常
 * @return
 */
@Lazy(value = false)
@Bean(name = "jackson2JsonRedisSerializer")
public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer(){
    Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer<>(Response.class);
    jsonRedisSerializer.setObjectMapper(jacksonMapper());
    return jsonRedisSerializer;
}


@Lazy(value =false)
@Bean (name = "stringRedisSerializer")
public StringRedisSerializer stringRedisSerializer(){
    return new StringRedisSerializer(StandardCharsets.UTF_8);
}

}

最后在需要的地方开启注解缓存即可
@CacheConfig(cacheManager = "redisCache",cacheNames = {"bxe"})
@Cacheable

弄这个破玩意好几天，尤其是spring data redis还挑lettuce的版本，我把git的源码下载一遍自己编译都报错，最后才发现是版本问题。
第二个坑：RedisSerializer需要指定对象的数据类型，不然反序列化报错。
第三： segmentfault的编辑器非常不好用。

--------update
上面的配置有个缺陷，就是只能指定数据类型去缓存到redis。

其实还可以配置一个GenericJackson2JsonRedisSerializer

@Bean(name = "jsonRedisSerializer")
public GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer(){
    GenericJackson2JsonRedisSerializer jsonRedisSerializer=new GenericJackson2JsonRedisSerializer(“@class);
    return jsonRedisSerializer;
}

但我持久层是 Spring data JPA。
查询分页结果时，会无法反序列化。
Could not read JSON: Cannot construct instance of `org.springframework.data.domain.PageImpl` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

搜了半天没解决方案。