web-dev-qa-db-ja.com

ElasticSearch 7.0バージョンをSpring Bootと統合するにはどうすればよいですか？

Mavenリポジトリですでに利用可能なElastic Searchライブラリの最新バージョンを使用しようとしています。

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.0.0</version>
</dependency>

しかし、6.5をインポートするSpring Bootで7番目のバージョンをどのように使用できるかわかりません。私のmaven依存関係：

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  </dependency>
springspring-bootelasticsearch
16
Sarvar Nishonboev

いつSpring Data Elastic Search 4.xがリリースされるか本当にわからないので、現在のSpring Data Elastic Search 4.xand stableSpring Boot 2.1.7 。 Springリポジトリと最新のElastic Searchを使用する場合は、一時的な回避策として機能する可能性があります。

1）依存関係で最新のエラスティック検索クライアントを強制します（私の場合：build.gradle）

dependencies {
    //Force spring-data to use the newest elastic-search client
    //this should removed as soon as spring-data-elasticsearch:4.0.0 is released!
    implementation('org.springframework.data:spring-data-elasticsearch:4.0.0.BUILD-SNAPSHOT') {
        exclude group: 'org.elasticsearch'
        exclude group: 'org.elasticsearch.plugin'
        exclude group: 'org.elasticsearch.client'
    }

    implementation('org.elasticsearch:elasticsearch:7.3.0') { force = true }
    implementation('org.elasticsearch.client:elasticsearch-rest-high-level-client:7.3.0') { force = true }
    implementation('org.elasticsearch.client:elasticsearch-rest-client:7.3.0') { force = true }
}

2）Elastic Searchの自動構成コンポーネントとヘルスチェックコンポーネントが互換性がなくなったときに無効にします（後で独自のヘルスチェックを実装することもできます）。

@SpringBootApplication(exclude = {ElasticsearchAutoConfiguration.class, ElasticSearchRestHealthIndicatorAutoConfiguration.class})
@EnableElasticsearchRepositories
public class SpringBootApp {

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

}

3）自動構成を無効にしたので、ElasticsearchRestTemplateを自分で初期化する必要があります。また、クラスの非互換性を回避するために、カスタムMappingElasticsearchConverterを提供するためにそれを行う必要があります。

/**
 * Manual configuration to support the newest ElasticSearch that is currently not supported by {@link org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration}.
 *
 * @author aleksanderlech
 */
@Configuration
@EnableConfigurationProperties(ElasticsearchProperties.class)
public class ElasticSearchConfiguration {

    @Primary
    @Bean
    public ElasticsearchRestTemplate elasticsearchTemplate(ElasticsearchProperties configuration) {
        var nodes =  Stream.of(configuration.getClusterNodes().split(",")).map(HttpHost::create).toArray(HttpHost[]::new);
        var client = new RestHighLevelClient(RestClient.builder(nodes));
        var converter = new CustomElasticSearchConverter(new SimpleElasticsearchMappingContext(), createConversionService());
        return new ElasticsearchRestTemplate(client, converter, new DefaultResultMapper(converter));
    }

    private DefaultConversionService createConversionService() {
        var conversionService = new DefaultConversionService();
        conversionService.addConverter(new StringToLocalDateConverter());
        return conversionService;
    }
}

CustomElasticSearchConverter：

/**
 * Custom version of {@link MappingElasticsearchConverter} to support newest Spring Data Elasticsearch integration that supports ElasticSearch 7. Remove when Spring Data Elasticsearch 4.x is released.
 */
class CustomElasticSearchConverter extends MappingElasticsearchConverter {

    private CustomConversions conversions = new ElasticsearchCustomConversions(Collections.emptyList());

    CustomElasticSearchConverter(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext) {
        super(mappingContext);
        setConversions(conversions);
    }

    CustomElasticSearchConverter(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext, GenericConversionService conversionService) {
        super(mappingContext, conversionService);
        setConversions(conversions);
    }

    @Override
    protected <R> R readValue(@Nullable Object source, ElasticsearchPersistentProperty property,
                              TypeInformation<R> targetType) {

        if (source == null) {
            return null;
        }

        if (source instanceof List) {
            return readCollectionValue((List) source, property, targetType);
        }

        return super.readValue(source, property, targetType);
    }

    private Object readSimpleValue(@Nullable Object value, TypeInformation<?> targetType) {

        Class<?> target = targetType.getType();

        if (value == null || target == null || ClassUtils.isAssignableValue(target, value)) {
            return value;
        }

        if (conversions.hasCustomReadTarget(value.getClass(), target)) {
            return getConversionService().convert(value, target);
        }

        if (Enum.class.isAssignableFrom(target)) {
            return Enum.valueOf((Class<Enum>) target, value.toString());
        }

        return getConversionService().convert(value, target);
    }


    private <R> R readCollectionValue(@Nullable List<?> source, ElasticsearchPersistentProperty property,
                                      TypeInformation<R> targetType) {

        if (source == null) {
            return null;
        }

        Collection<Object> target = createCollectionForValue(targetType, source.size());

        for (Object value : source) {

            if (isSimpleType(value)) {
                target.add(
                        readSimpleValue(value, targetType.getComponentType() != null ? targetType.getComponentType() : targetType));
            } else {

                if (value instanceof List) {
                    target.add(readValue(value, property, property.getTypeInformation().getActualType()));
                } else {
                    target.add(readEntity(computeGenericValueTypeForRead(property, value), (Map) value));
                }
            }
        }

        return (R) target;
    }

    private Collection<Object> createCollectionForValue(TypeInformation<?> collectionTypeInformation, int size) {

        Class<?> collectionType = collectionTypeInformation.isCollectionLike()//
                ? collectionTypeInformation.getType() //
                : List.class;

        TypeInformation<?> componentType = collectionTypeInformation.getComponentType() != null //
                ? collectionTypeInformation.getComponentType() //
                : ClassTypeInformation.OBJECT;

        return collectionTypeInformation.getType().isArray() //
                ? new ArrayList<>(size) //
                : CollectionFactory.createCollection(collectionType, componentType.getType(), size);
    }

    private ElasticsearchPersistentEntity<?> computeGenericValueTypeForRead(ElasticsearchPersistentProperty property,
                                                                            Object value) {

        return ClassTypeInformation.OBJECT.equals(property.getTypeInformation().getActualType())
                ? getMappingContext().getRequiredPersistentEntity(value.getClass())
                : getMappingContext().getRequiredPersistentEntity(property.getTypeInformation().getActualType());
    }

    private boolean isSimpleType(Object value) {
        return isSimpleType(value.getClass());
    }

    private boolean isSimpleType(Class<?> type) {
        return conversions.isSimpleType(type);
    }

}
9
Aleksander Lech

誰かがSpring Boot 2.1.2およびKotlinを使用している場合、次のコードが役立つ場合があります。私はいくつかの小さな変更を加えて、@ Alexander Lechの回答から翻訳しました：

Alexanders Answerへの最初の変更：

@SpringBootApplication(exclude = [ElasticsearchAutoConfiguration::class, 
ElasticsearchDataAutoConfiguration::class])

機能させるために、ElasticsearchDataAutoConfigurationを除外する必要がありました。

2番目：Kotlinを使用しており、カスタムコンバーターが大量のコードであるため、このKotlinへの変換は誰かを助けるでしょう：

class CustomElasticSearchConverter(mappingContext: MappingContext<out ElasticsearchPersistentEntity<*>, ElasticsearchPersistentProperty>, customConversionService: GenericConversionService?) : MappingElasticsearchConverter(mappingContext, customConversionService) {

    private val conversionsNew = ElasticsearchCustomConversions(emptyList<Any>())

    init {
        setConversions(conversionsNew)
    }

    override fun <R : Any?> readValue(source: Any?, property: ElasticsearchPersistentProperty, targetType: TypeInformation<R>): R? {
        if (source == null) {
            return null
        }

        if (source is Collection<*>) {
            return readCollectionValue(source, property, targetType) as R?;
        }

        return super.readValue(source, property, targetType);
    }

    private fun readCollectionValue(source: Collection<*>?, property: ElasticsearchPersistentProperty, targetType: TypeInformation<*>): Any? {

        if (source == null) {
            return null
        }

        val target = createCollectionForValue(targetType, source.size)

        for (value in source) {
            require(value != null) { "value must not be null" }

            if (isSimpleType(value)) {
                target.add(readSimpleValue(value, if (targetType.componentType != null) targetType.componentType!! else targetType))
            } else {
                if (value is MutableCollection<*>) {
                    target.add(readValue(value, property, property.typeInformation.actualType as TypeInformation<out Any>))
                } else {
                    @Suppress("UNCHECKED_CAST")
                    target.add(readEntity(computeGenericValueTypeForRead(property, value), value as MutableMap<String, Any>?))
                }
            }
        }

        return target
    }

    private fun readSimpleValue(value: Any?, targetType: TypeInformation<*>): Any? {

        val target = targetType.type

        @Suppress("SENSELESS_COMPARISON")
        if (value == null || target == null || ClassUtils.isAssignableValue(target, value)) {
            return value
        }

        if (conversionsNew.hasCustomReadTarget(value.javaClass, target)) {
            return conversionService.convert(value, target)
        }

        @Suppress("UNCHECKED_CAST")
        return when {
            Enum::class.Java.isAssignableFrom(target) -> enumByName(target as Class<Enum<*>>, value.toString())
            else -> conversionService.convert(value, target)
        }
    }

    private fun enumByName(target: Class<Enum<*>>, name: String): Enum<*> {
        val enumValue = target.enumConstants.find { it.name == name }
        require(enumValue != null) { "no enum value found for name $name and targetClass $target" }
        return enumValue
    }

    private fun createCollectionForValue(collectionTypeInformation: TypeInformation<*>, size: Int): MutableCollection<Any?> {

        val collectionType = when {
            collectionTypeInformation.isCollectionLike -> collectionTypeInformation.type
            else -> MutableList::class.Java
        }

        val componentType = when {
            collectionTypeInformation.componentType != null -> collectionTypeInformation.componentType
            else -> ClassTypeInformation.OBJECT
        }

        return when {
            collectionTypeInformation.type.isArray -> ArrayList(size)
            else -> CollectionFactory.createCollection(collectionType, componentType!!.type, size)
        }
    }

    private fun computeGenericValueTypeForRead(property: ElasticsearchPersistentProperty, value: Any): ElasticsearchPersistentEntity<*> {

        return when {
            ClassTypeInformation.OBJECT == property.typeInformation.actualType -> mappingContext.getRequiredPersistentEntity(value.javaClass)
            else -> mappingContext.getRequiredPersistentEntity(property.typeInformation.actualType!!)
        }
    }

    private fun isSimpleType(value: Any): Boolean {
        return isSimpleType(value.javaClass)
    }

    private fun isSimpleType(type: Class<*>): Boolean {
        return conversionsNew.isSimpleType(type)
    }

}

この後、いくつかのリポジトリクエリの問題が解決しました。 spring-boot-starter-data-elasticsearchではなくspring-data-elasticsearch:4.0.0.BUILD-SNAPSHOTを使用しないように注意してください。 （これには少し時間がかかりました）。

はい、コードは醜いですが、spring-data-elasticsearch:4.0.0がリリースされた後は破棄できます。

1
Bernhard Kern