springboot集成es，配置elasticsearch_springboot配置es

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);
      }


   }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237

测试

    @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);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13