Spring boot Spring Data 3.0.5 MongoDB和ElasticSearch域类混合注释

我正在将我们的应用程序从Spring Boot 1.5.9迁移到2.0.0版

在版本1.5.9中，我们成功地在几个域类上使用了混合注释，例如：

。。。
@org.springframework.data.mongodb.core.mapping.Document（collection=“folder”）
@org.springframework.data.elasticsearch.annotations.Document（indexName=“folder”）
公共类文件夹{
...
}

同样的方法在SpringBoot2.0.0中也会引起问题。当使用MongoDB注释@DBRef时，Spring在创建ElasticsearchRepository时抛出异常：

java.lang.IllegalStateException:未找到关联！

课程和座谈会来了

pom.xml

。。。
1.8
org.springfrsamework.boot

我的问题:


在SpringBoot2.0.0中，是否有任何解决方案可以处理域类（mongo和elastic）上的混合注释
我也有同样的问题，我找到的解决方案是扩展SimpleLasticSearchAppingContext，如下所示：

package com.mypackage;

    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.elasticsearch.client.Client;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
    import org.springframework.data.elasticsearch.core.EntityMapper;
    import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
    import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

    import java.io.IOException;

    @Configuration
    public class ElasticsearchConfiguration {

        @Bean
        public ElasticsearchTemplate elasticsearchTemplate(Client client, Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder) {
            return new ElasticsearchTemplate(client, new MappingElasticsearchConverter(new CustomElasticsearchMappingContext()),
                new CustomEntityMapper(jackson2ObjectMapperBuilder.createXmlMapper(false).build()));
        }

        public class CustomEntityMapper implements EntityMapper {

            private ObjectMapper objectMapper;

            public CustomEntityMapper(ObjectMapper objectMapper) {
                this.objectMapper = objectMapper;
                objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
                objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
            }

            @Override
            public String mapToString(Object object) throws IOException {
                return objectMapper.writeValueAsString(object);
            }

            @Override
            public  T mapToObject(String source, Class clazz) throws IOException {
                return objectMapper.readValue(source, clazz);
            }
        }
    }

    package com.mypackage;

    import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty;
    import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
    import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchPersistentEntity;
    import org.springframework.data.mapping.model.Property;
    import org.springframework.data.mapping.model.SimpleTypeHolder;

    public class CustomElasticsearchMappingContext extends SimpleElasticsearchMappingContext {
        @Override
        protected ElasticsearchPersistentProperty createPersistentProperty(Property property, SimpleElasticsearchPersistentEntity owner, SimpleTypeHolder simpleTypeHolder) {
            return new CustomElasticsearchPersistentProperty(property, owner, simpleTypeHolder);
        }
    }

    package com.mypackage;

    import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty;
    import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchPersistentProperty;
    import org.springframework.data.mapping.PersistentEntity;
    import org.springframework.data.mapping.model.Property;
    import org.springframework.data.mapping.model.SimpleTypeHolder;

    public class CustomElasticsearchPersistentProperty extends SimpleElasticsearchPersistentProperty {

        public CustomElasticsearchPersistentProperty(Property property, PersistentEntity owner, SimpleTypeHolder simpleTypeHolder) {
            super(property, owner, simpleTypeHolder);
        }

        @Override
        public boolean isAssociation() {
            return false;
        }
    }
package com.mypackage；
导入com.fasterxml.jackson.databind.DeserializationFeature；
导入com.fasterxml.jackson.databind.ObjectMapper；
导入org.elasticsearch.client.client；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.data.elasticsearch.core.ElasticsearchTemplate；
导入org.springframework.data.elasticsearch.core.EntityMapper；
导入org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter；
导入org.springframework.http.converter.json.Jackson2ObjectMapperBuilder；
导入java.io.IOException；
@配置
公共类ElasticsearchConfiguration{
@豆子
公共ElasticsearchTemplate ElasticsearchTemplate（客户端，Jackson2ObjectMapperBuilder Jackson2ObjectMapperBuilder）{
返回新的ElasticsearchTemplate（客户端，新映射ElasticSearchConverter（新CustomElasticsearchMappingContext（）），
新的CustomEntityMapper（jackson2ObjectMapperBuilder.createXmlMapper（false.build（））；
}
公共类CustomEntityMapper实现EntityMapper{
私有对象映射器对象映射器；
公共CustomEntityMapper（ObjectMapper ObjectMapper）{
this.objectMapper=objectMapper；
objectMapper.configure（在未知属性上反序列化feature.FAIL，false）；
configure（反序列化功能。接受单个值作为数组，true）；
}
@凌驾
公共字符串mapToString（对象对象）引发IOException{
返回objectMapper.writeValueAsString（对象）；
}
@凌驾
公共T mapToObject（字符串源，类clazz）引发IOException{
返回objectMapper.readValue（源，clazz）；
}
}
}
package com.mypackage；
导入org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty；
导入org.springframework.data.elasticsearch.core.mapping.SimpleLasticSearchAppingContext；
导入org.springframework.data.elasticsearch.core.mapping.SimpleLasticSearchPersistentEntity；
导入org.springframework.data.mapping.model.Property；
导入org.springframework.data.mapping.model.SimpleTypeHolder；
公共类CustomElasticsearchMappingContext扩展了SimpleLasticSearchMappingContext{
@凌驾
受保护的ElasticsearchPersistentProperty createPersistentProperty（Property属性，SimpleLasticSearchPersistentEntity所有者，SimpleTypeHolder SimpleTypeHolder）{
返回新的CustomElasticsearchPersistentProperty（属性、所有者、simpleTypeHolder）；
}
}
package com.mypackage；
导入org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty；
导入org.springframework.data.elasticsearch.core.mapping.SimpleLasticSearchPersistentProperty；
导入org.springframework.data.mapping.PersistentEntity；
导入org.springframework.data.mapping.model.Property；
导入org.springframework.data.mapping.model.SimpleTypeHolder；
公共类CustomElasticsearchPersistentProperty扩展了SimpleLasticSearchPersistentProperty{
公共CustomElasticsearchPersistentProperty（属性属性、PersistentEntity所有者、SimpleTypeHolder SimpleTypeHolder）{
超级（财产、所有者、简单持有人）；
}
@凌驾
公共布尔isAssociation（）{
返回false；
}
}
我也遇到过这个问题，我用@ybouraze解决了这个问题

@Bean
fun elasticsearchTemplate(client: JestClient, converter: ElasticsearchConverter, builder: Jackson2ObjectMapperBuilder): ElasticsearchOperations {
    val entityMapper = CustomEntityMapper(builder.createXmlMapper(false).build())
    val mapper = DefaultJestResultsMapper(converter.mappingContext, entityMapper)
    return JestElasticsearchTemplate(client, converter, mapper)
}

@Bean
@Primary
fun mappingContext(): SimpleElasticsearchMappingContext {
    return MappingContext()
}

@Bean
fun elasticsearchConverter(): ElasticsearchConverter {
    return MappingElasticsearchConverter(mappingContext())
}

inner class CustomEntityMapper(private val objectMapper: ObjectMapper) : EntityMapper {

    init {
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true)
    }

    @Throws(IOException::class)
    override fun mapToString(`object`: Any): String {
        return objectMapper.writeValueAsString(`object`)
    }

    @Throws(IOException::class)
    override fun <T> mapToObject(source: String, clazz: Class<T>): T {
        return objectMapper.readValue(source, clazz)
    }
}

inner class MappingContext : SimpleElasticsearchMappingContext() {
    override fun createPersistentProperty(property: Property, owner: SimpleElasticsearchPersistentEntity<*>, simpleTypeHolder: SimpleTypeHolder): ElasticsearchPersistentProperty {
        return PersistentProperty(property, owner, simpleTypeHolder)
    }
}

inner class PersistentProperty(property: Property, owner: SimpleElasticsearchPersistentEntity<*>, simpleTypeHolder: SimpleTypeHolder) : SimpleElasticsearchPersistentProperty(property, owner, simpleTypeHolder) {
    override fun isAssociation(): Boolean {
        return false
    }
}

@Bean
有趣的elasticsearchTemplate（客户端：JestClient，转换器：ElasticsearchConverter，生成器：Jackson2ObjectMapperBuilder）：ElasticsearchOperations{
val entityMapper=CustomEntityMapper（builder.createXmlMapper（false.build（））
val mapper=DefaultJestResultsMapper（converter.mappingContext，entityMapper）
返回JestElasticsearchTemplate（客户端、转换器、映射器）
}
@豆子
@初级的
fun mappingContext（）：SimpleLasticSearchMappingContext{
返回MappingContext（）
}
@豆子
趣味elasticsearchConverter（）：elasticsearchConverter{
返回MappingElasticsearchConverter（mappingContext（））
}
内部类CustomEntityMapper（私有val对象映射器：对象映射器）：EntityMapper{
初始化{
objectMapper.configure（在未知属性上反序列化Feature.FAIL，false）
objectMapper.configure（反序列化功能。接受单个值作为数组，true）
}
@抛出（IOException:：类）
override fun mapToString（`object`:Any）：字符串{
返回objectMapper.writeValueAsString（`object`）
}
@抛出（IOException:：类）
重写有趣的mapToObject（源：String，clazz:Class）：T{
返回objectMapper.readValue（源代码，cla