java - 具有复杂键的 Spring Data Redis 存储库

Question

我们尝试使用 Spring Data CrudRepository在我们的项目中为我们的域对象提供持久性。
一开始，我选择 REDIS 作为后端，因为在第一次使用 CrudRepository<ExperimentDomainObject, String> 的实验中看起来，让它运行起来很容易。

当试图将它放入我们的生产代码中时，事情变得更加复杂，因为在这里我们的域对象没有必要使用简单类型作为键，所以存储库是 CrudRepository<TestObject, ObjectId> .

现在我得到了异常:

No converter found capable of converting from type [...ObjectId] to type [byte[]]

搜索此异常，this answer这导致我对 RedisTemplate 进行了未受过教育的实验配置。 (对于我的实验，我使用的是 emdedded-redis)

我的想法是，提供一个 RedisTemplate<Object, Object>而不是 RedisTemplate<String, Object>允许使用 Jackson2JsonRedisSerializer也可以作为 keySerializer 完成工作。

仍在调用 testRepository.save(testObject)失败。

请看我的代码:

为了本示例的简洁，我有公共(public)字段并省略了导入。如果需要它们(使其成为 MVCE)，我会很乐意提供它们。请给我留言。

dependencies:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    implementation group: 'redis.clients', name: "jedis", version: '2.9.0'
    implementation group: 'it.ozimov', name: 'embedded-redis', version: '0.7.2'
}

RedisConfiguration:

@Configuration
@EnableRedisRepositories
public class RedisConfiguration {
    @Bean
    JedisConnectionFactory jedisConnectionFactory() {
        return new JedisConnectionFactory();
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        final RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setEnableDefaultSerializer(true);

        return template;
    }
}

TestObject

@RedisHash("test")
public class TestObject
{
    @Id public ObjectId testId;
    public String value;

    public TestObject(ObjectId id, String value)
    {
        this.testId = id;
        this.value = value; // In experiment this is: "magic"
    }
}

ObjectId

@EqualsAndHashCode
public class ObjectId {
    public String creator; // In experiment, this is "me"
    public String name;    // In experiment, this is "fool"
}

TestRepository

@Repository
public interface TestRepository extends CrudRepository<TestObject, ObjectId>
{
}

EmbeddedRedisConfiguration

@Configuration
public class EmbeddedRedisConfiguration
{
    private final redis.embedded.RedisServer redisServer;

    EmbeddedRedisConfiguration(RedisProperties redisProperties)
    {
        this.redisServer = new redis.embedded.RedisServer(redisProperties.getPort());
    }

    @PostConstruct
    public void init()
    {
        redisServer.start();
    }

    @PreDestroy
    public void shutdown()
    {
        redisServer.stop();
    }
}

Application:

@SpringBootApplication
public class ExperimentApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(ExperimentApplication.class, args);
    }
}

不是想要的答案:

当然，我可能会引入一些特殊的ID，它是一种简单的数据类型，例如我使用 jacksons ObjectMapper 手动构建的 JSON 字符串，然后使用 CrudRepository<TestObject, String> .

同时我还尝试了:

• RedisTemplate<String, String>
• RedisTemplate<String, Object>
• Autowiring RedisTemplate并设置其默认序列化程序
• 注册Converter<ObjectId, byte[]>到
  • Autowiring ConverterRegistry
  • Autowiring GenericConversionService
    但显然他们错了。

Answer 1

基本上，Redis 存储库在底层使用 RedisKeyValueTemplate 将数据存储为键 (Id) 和值对。所以你对 RedisTemplate 的配置将不起作用，除非你直接使用它。

因此，您的一种方法是直接使用 RedistTemplate，这样的方法适合您。

@Service
public class TestService {

    @Autowired
    private RedisTemplate redisTemplate;

    public void saveIt(TestObject testObject){
        ValueOperations<ObjectId, TestObject> values = redisTemplate.opsForValue();
        values.set(testObject.testId, testObject);
    }

}

所以上面的代码将使用您的配置并使用 Jackson 作为键和值的映射器在 Redis 中生成字符串对。

但是如果你想通过 CrudRepository 使用 Redis Repositories，你需要为 ObjectId 创建读写转换器，从 String 和byte[] 并将它们注册为自定义 Redis 转换。

那么让我们为 ObjectId 创建读写转换器 <-> String

读者

@Component
@ReadingConverter
@Slf4j
public class RedisReadingStringConverter implements Converter<String, ObjectId> {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public ObjectId convert(String source) {
        try {
            return objectMapper.readValue(source, ObjectId.class);
        } catch (IOException e) {
            log.warn("Error while converting to ObjectId.", e);
            throw new IllegalArgumentException("Can not convert to ObjectId");
        }
    }
}

作家

@Component
@WritingConverter
@Slf4j
public class RedisWritingStringConverter implements Converter<ObjectId, String> {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public String convert(ObjectId source) {
        try {
            return objectMapper.writeValueAsString(source);
        } catch (JsonProcessingException e) {
            log.warn("Error while converting ObjectId to String.", e);
            throw new IllegalArgumentException("Can not convert ObjectId to String");
        }
    }
}

以及ObjectId的读写转换器<-> byte[]

作家

@Component
@WritingConverter
public class RedisWritingByteConverter implements Converter<ObjectId, byte[]> {

    Jackson2JsonRedisSerializer<ObjectId> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(ObjectId.class);

    @Override
    public byte[] convert(ObjectId source) {
        return jackson2JsonRedisSerializer.serialize(source);
    }
}

读者

@Component
@ReadingConverter
public class RedisReadingByteConverter implements Converter<byte[], ObjectId> {

     Jackson2JsonRedisSerializer<ObjectId> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(ObjectId.class);

    @Override
    public ObjectId convert(byte[] source) {
        return jackson2JsonRedisSerializer.deserialize(source);
    }
}

最后添加 Redis 自定义对话。只需将代码放入 RedisConfiguration

@Bean
public RedisCustomConversions redisCustomConversions(RedisReadingByteConverter readingConverter,
                                                     RedisWritingByteConverter redisWritingConverter,
                                                     RedisWritingStringConverter redisWritingByteConverter,
                                                     RedisReadingStringConverter redisReadingByteConverter) {
    return new RedisCustomConversions(Arrays.asList(readingConverter, redisWritingConverter, redisWritingByteConverter, redisReadingByteConverter));
}

现在，在创建转换器并将其注册为自定义 Redis 转换器之后，RedisKeyValueTemplate 可以使用它们，您的代码应该可以按预期工作。