集成 Spring data redis 笔记

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

1 ：引入依赖

<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-redis</artifactId>
  <version>${spring-data-redis.version}</version>
</dependency>
<!-- spring-data-redis 1.8须要commons-pool2，若是要用到链接池的话  -->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
  <version>${commons-pool2.version}</version>
</dependency>

<!-- spring-data-redis实现了lettuceFactory，可是1.8针对的是lettuce 4.X的实现，所以不能使用高版本 -->
<dependency>
  <groupId>biz.paluch.redis</groupId>
  <artifactId>lettuce</artifactId>
  <version>${lettuce.version}</version>
</dependency>

---

/**
 * 配置缓存
 */

@EnableCaching
public class CachingConfig extends CachingConfigurerSupport {

@Resource(name = "redisTemplate")
private RedisTemplate<Object, Object> 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<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory,
                                                   Jackson2JsonRedisSerializer<Response> jackson2JsonRedisSerializer,
                                                   StringRedisSerializer stringRedisSerializer) {
    RedisTemplate<Object, Object> 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<Response> jackson2JsonRedisSerializer(){
    Jackson2JsonRedisSerializer<Response> 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)

搜了半天没解决方案。