springboot集成es，配置elasticsearch

springboot项目配置项

1. 首先创建一个空项目
2. 然后在空项目中新建一个springboot的空模块
3. 创建时，勾选上默认的，web的第一个 和nosql中的elasticsearch。
4. 在file》project structure 中 修改project的jdk版本，module中也修改jdk对应版本
   （修改为自己本地安装的jdk版本，es对jdk要求1.8以上）
5. 在file》setings 中搜索java compiler 中修改module中第一个版本为1.8
6. 在file》setings 中搜索javaScript 中修改language version为ECMAScript 6
   这个地方不修改，可以有些命令不支持使用
   

elasticsearch配置（大部分人跑不起来的原因）

我的是本地搭建了es，所以要和本地的对应
查看es版本：

我本地是elasticsearch-7.6.1。现在来自定义依赖
找到默认版本的信息，下面的地方点进去

在这里找到了默认的版本
复制过来 修改

刷新查看是否修改过来

配置使用

现在开始使用咯，首先我们在项目中新建如下目录，和文件

在config中的配置文件中，我们是现在官网上找到了java高级REST客户端

放到spring中待用，如下通过bean注入到springboot中

分析源码

es源码位置


源码开始位置

/*
* Copyright 2012-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/


package org.springframework.boot.autoconfigure.elasticsearch;


import java.net.URI;
import java.net.URISyntaxException;
import java.time.Duration;


import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.sniff.Sniffer;
import org.elasticsearch.client.sniff.SnifferBuilder;


import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;


/**
* Elasticsearch rest client configurations.
*
* @author Stephane Nicoll
*/
class ElasticsearchRestClientConfigurations {


   @Configuration(proxyBeanMethods = false)
   @ConditionalOnMissingBean(RestClientBuilder.class)
   static class RestClientBuilderConfiguration {


      @Bean
      RestClientBuilderCustomizer defaultRestClientBuilderCustomizer(ElasticsearchRestClientProperties properties) {
         return new DefaultRestClientBuilderCustomizer(properties);
      }


      @Bean
      RestClientBuilder elasticsearchRestClientBuilder(ElasticsearchRestClientProperties properties,
            ObjectProvider<RestClientBuilderCustomizer> builderCustomizers) {
         HttpHost[] hosts = properties.getUris().stream().map(this::createHttpHost).toArray(HttpHost[]::new);
         RestClientBuilder builder = RestClient.builder(hosts);
         builder.setHttpClientConfigCallback((httpClientBuilder) -> {
            builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(httpClientBuilder));
            return httpClientBuilder;
         });
         builder.setRequestConfigCallback((requestConfigBuilder) -> {
            builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(requestConfigBuilder));
            return requestConfigBuilder;
         });
         builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
         return builder;
      }


      private HttpHost createHttpHost(String uri) {
         try {
            return createHttpHost(URI.create(uri));
         }
         catch (IllegalArgumentException ex) {
            return HttpHost.create(uri);
         }
      }


      private HttpHost createHttpHost(URI uri) {
         if (!StringUtils.hasLength(uri.getUserInfo())) {
            return HttpHost.create(uri.toString());
         }
         try {
            return HttpHost.create(new URI(uri.getScheme(), null, uri.getHost(), uri.getPort(), uri.getPath(),
                  uri.getQuery(), uri.getFragment()).toString());
         }
         catch (URISyntaxException ex) {
            throw new IllegalStateException(ex);
         }
      }


   }


   @Configuration(proxyBeanMethods = false)
   @ConditionalOnMissingBean(RestHighLevelClient.class)
   static class RestHighLevelClientConfiguration {


      @Bean
      RestHighLevelClient elasticsearchRestHighLevelClient(RestClientBuilder restClientBuilder) {
         return new RestHighLevelClient(restClientBuilder);
      }


   }


   @Configuration(proxyBeanMethods = false)
   @ConditionalOnClass(Sniffer.class)
   @ConditionalOnSingleCandidate(RestHighLevelClient.class)
   static class RestClientSnifferConfiguration {


      @Bean
      @ConditionalOnMissingBean
      Sniffer elasticsearchSniffer(RestHighLevelClient client, ElasticsearchRestClientProperties properties) {
         SnifferBuilder builder = Sniffer.builder(client.getLowLevelClient());
         PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
         map.from(properties.getSniffer().getInterval()).asInt(Duration::toMillis)
               .to(builder::setSniffIntervalMillis);
         map.from(properties.getSniffer().getDelayAfterFailure()).asInt(Duration::toMillis)
               .to(builder::setSniffAfterFailureDelayMillis);
         return builder.build();
      }


   }


   static class DefaultRestClientBuilderCustomizer implements RestClientBuilderCustomizer {


      private static final PropertyMapper map = PropertyMapper.get();


      private final ElasticsearchRestClientProperties properties;


      DefaultRestClientBuilderCustomizer(ElasticsearchRestClientProperties properties) {
         this.properties = properties;
      }


      @Override
      public void customize(RestClientBuilder builder) {
      }


      @Override
      public void customize(HttpAsyncClientBuilder builder) {
         builder.setDefaultCredentialsProvider(new PropertiesCredentialsProvider(this.properties));
      }


      @Override
      public void customize(RequestConfig.Builder builder) {
         map.from(this.properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis)
               .to(builder::setConnectTimeout);
         map.from(this.properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis)
               .to(builder::setSocketTimeout);
      }


   }


   private static class PropertiesCredentialsProvider extends BasicCredentialsProvider {


      PropertiesCredentialsProvider(ElasticsearchRestClientProperties properties) {
         if (StringUtils.hasText(properties.getUsername())) {
            Credentials credentials = new UsernamePasswordCredentials(properties.getUsername(),
                  properties.getPassword());
            setCredentials(AuthScope.ANY, credentials);
         }
         properties.getUris().stream().map(this::toUri).filter(this::hasUserInfo)
               .forEach(this::addUserInfoCredentials);
      }


      private URI toUri(String uri) {
         try {
            return URI.create(uri);
         }
         catch (IllegalArgumentException ex) {
            return null;
         }
      }


      private boolean hasUserInfo(URI uri) {
         return uri != null && StringUtils.hasLength(uri.getUserInfo());
      }


      private void addUserInfoCredentials(URI uri) {
         AuthScope authScope = new AuthScope(uri.getHost(), uri.getPort());
         Credentials credentials = createUserInfoCredentials(uri.getUserInfo());
         setCredentials(authScope, credentials);
      }


      private Credentials createUserInfoCredentials(String userInfo) {
         int delimiter = userInfo.indexOf(":");
         if (delimiter == -1) {
            return new UsernamePasswordCredentials(userInfo, null);
         }
         String username = userInfo.substring(0, delimiter);
         String password = userInfo.substring(delimiter + 1);
         return new UsernamePasswordCredentials(username, password);
      }


   }


}

测试

    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    //测试创建索引的请求
    @Test
    void testCreateIndex() throws IOException {
        //创建索引请求
        CreateIndexRequest haixin2 = new CreateIndexRequest("haixin2");
        //调用客户端执行请求 IndicesClient，请求后获得响应
        CreateIndexResponse createIndexResponse = client.indices().create(haixin2, RequestOptions.DEFAULT);
        System.out.println("哈哈哈哈" + createIndexResponse);
    }