SpringBoot2集成Elasticsearch8（使用spring-boot-starter-data-elasticsea ...

写在前面

使用spring-boot-starter-data-elasticsearch集成Elasticsearch8？
What? 官方写的不支持啊？让我们来看下官方给出的版本建议。

官方地址：
https://docs.spring.io/spring-data/elasticsearch/reference/elasticsearch/versions.html
实际需求

大部分稳定的生产系统仍然使用的是SpringBoot2.x,即使使用最新的SpringBoot2.7.x,
也会发现使用spring-boot-starter-data-elasticsearch去连接Elasticsearch8也是连不上的。具体报错就不贴了，但是你说我们升级SpringBoot3？固然可以，但是jdk也得升级，
生产系统那种运行的稳定的一批的客户能同意，领导能同意么？显然是，很难。
深入源码

废话不多说，先说改造方案，就是我们本身使用自定义的类覆盖官方的默认实现。
案比方下：

1. /*
2. * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
3. * or more contributor license agreements. Licensed under the Elastic License
4. * 2.0 and the Server Side Public License, v 1; you may not use this file except
5. * in compliance with, at your election, the Elastic License 2.0 or the Server
6. * Side Public License, v 1.
7. */
8. package org.elasticsearch.action;
10. import cn.hutool.core.util.StrUtil;
11. import org.elasticsearch.Version;
12. import org.elasticsearch.action.support.WriteRequest;
13. import org.elasticsearch.action.support.WriteRequest.RefreshPolicy;
14. import org.elasticsearch.action.support.WriteResponse;
15. import org.elasticsearch.action.support.replication.ReplicationResponse;
16. import org.elasticsearch.cluster.metadata.IndexMetadata;
17. import org.elasticsearch.common.io.stream.StreamInput;
18. import org.elasticsearch.common.io.stream.StreamOutput;
19. import org.elasticsearch.common.io.stream.Writeable;
20. import org.elasticsearch.common.xcontent.StatusToXContentObject;
21. import org.elasticsearch.core.Nullable;
22. import org.elasticsearch.index.Index;
23. import org.elasticsearch.index.IndexSettings;
24. import org.elasticsearch.index.seqno.SequenceNumbers;
25. import org.elasticsearch.index.shard.ShardId;
26. import org.elasticsearch.rest.RestStatus;
27. import org.elasticsearch.xcontent.XContentBuilder;
28. import org.elasticsearch.xcontent.XContentParser;
30. import java.io.IOException;
31. import java.io.UnsupportedEncodingException;
32. import java.net.URLEncoder;
33. import java.util.Locale;
34. import java.util.Objects;
36. import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
37. import static org.elasticsearch.index.seqno.SequenceNumbers.UNASSIGNED_PRIMARY_TERM;
38. import static org.elasticsearch.index.seqno.SequenceNumbers.UNASSIGNED_SEQ_NO;
40. /**
41. * A base class for the response of a write operation that involves a single doc
42. */
43. public abstract class DocWriteResponse extends ReplicationResponse implements WriteResponse, StatusToXContentObject {
45.     private static final String _SHARDS = "_shards";
46.     private static final String _INDEX = "_index";
47.     private static final String _TYPE = "_type";
48.     private static final String _ID = "_id";
49.     private static final String _VERSION = "_version";
50.     private static final String _SEQ_NO = "_seq_no";
51.     private static final String _PRIMARY_TERM = "_primary_term";
52.     private static final String RESULT = "result";
53.     private static final String FORCED_REFRESH = "forced_refresh";
55.     /**
56.      * An enum that represents the results of CRUD operations, primarily used to communicate the type of
57.      * operation that occurred.
58.      */
59.     public enum Result implements Writeable {
60.         CREATED(0),
61.         UPDATED(1),
62.         DELETED(2),
63.         NOT_FOUND(3),
64.         NOOP(4);
66.         private final byte op;
67.         private final String lowercase;
69.         Result(int op) {
70.             this.op = (byte) op;
71.             this.lowercase = this.name().toLowerCase(Locale.ROOT);
72.         }
74.         public byte getOp() {
75.             return op;
76.         }
78.         public String getLowercase() {
79.             return lowercase;
80.         }
82.         public static Result readFrom(StreamInput in) throws IOException {
83.             Byte opcode = in.readByte();
84.             switch (opcode) {
85.                 case 0:
86.                     return CREATED;
87.                 case 1:
88.                     return UPDATED;
89.                 case 2:
90.                     return DELETED;
91.                 case 3:
92.                     return NOT_FOUND;
93.                 case 4:
94.                     return NOOP;
95.                 default:
96.                     throw new IllegalArgumentException("Unknown result code: " + opcode);
97.             }
98.         }
100.         @Override
101.         public void writeTo(StreamOutput out) throws IOException {
102.             out.writeByte(op);
103.         }
104.     }
106.     private final ShardId shardId;
107.     private final String id;
108.     private final String type;
109.     private final long version;
110.     private final long seqNo;
111.     private final long primaryTerm;
112.     private boolean forcedRefresh;
113.     protected final Result result;
115.     public DocWriteResponse(ShardId shardId, String type, String id, long seqNo, long primaryTerm, long version, Result result) {
116.         this.shardId = Objects.requireNonNull(shardId);
117.         this.type = StrUtil.isEmpty(type)?"_doc":type;
118.         this.id = Objects.requireNonNull(id);
119.         this.seqNo = seqNo;
120.         this.primaryTerm = primaryTerm;
121.         this.version = version;
122.         this.result = Objects.requireNonNull(result);
123.     }
125.     // needed for deserialization
126.     protected DocWriteResponse(ShardId shardId, StreamInput in) throws IOException {
127.         this.shardId = shardId;
128.         String typeTmp = in.readString();
129.         type =  StrUtil.isEmpty(typeTmp)?"_doc":typeTmp;;
130.         id = in.readString();
131.         version = in.readZLong();
132.         seqNo = in.readZLong();
133.         primaryTerm = in.readVLong();
134.         forcedRefresh = in.readBoolean();
135.         result = Result.readFrom(in);
136.     }
138.     /**
139.      * Needed for deserialization of single item requests in {@link org.elasticsearch.action.index.IndexAction} and BwC
140.      * deserialization path
141.      */
142.     protected DocWriteResponse(StreamInput in) throws IOException {
143.         super(in);
144.         shardId = new ShardId(in);
145.         String typeTmp = in.readString();
146.         type =  StrUtil.isEmpty(typeTmp)?"_doc":typeTmp;;
147.         id = in.readString();
148.         version = in.readZLong();
149.         if (in.getVersion().onOrAfter(Version.V_6_0_0_alpha1)) {
150.             seqNo = in.readZLong();
151.             primaryTerm = in.readVLong();
152.         } else {
153.             seqNo = UNASSIGNED_SEQ_NO;
154.             primaryTerm = UNASSIGNED_PRIMARY_TERM;
155.         }
156.         forcedRefresh = in.readBoolean();
157.         result = Result.readFrom(in);
158.     }
160.     /**
161.      * The change that occurred to the document.
162.      */
163.     public Result getResult() {
164.         return result;
165.     }
167.     /**
168.      * The index the document was changed in.
169.      */
170.     public String getIndex() {
171.         return this.shardId.getIndexName();
172.     }
174.     /**
175.      * The exact shard the document was changed in.
176.      */
177.     public ShardId getShardId() {
178.         return this.shardId;
179.     }
181.     /**
182.      * The type of the document changed.
183.      *
184.      * @deprecated Types are in the process of being removed.
185.      */
186.     @Deprecated
187.     public String getType() {
188.         return this.type;
189.     }
191.     /**
192.      * The id of the document changed.
193.      */
194.     public String getId() {
195.         return this.id;
196.     }
198.     /**
199.      * Returns the current version of the doc.
200.      */
201.     public long getVersion() {
202.         return this.version;
203.     }
205.     /**
206.      * Returns the sequence number assigned for this change. Returns {@link SequenceNumbers#UNASSIGNED_SEQ_NO} if the operation
207.      * wasn't performed (i.e., an update operation that resulted in a NOOP).
208.      */
209.     public long getSeqNo() {
210.         return seqNo;
211.     }
213.     /**
214.      * The primary term for this change.
215.      *
216.      * @return the primary term
217.      */
218.     public long getPrimaryTerm() {
219.         return primaryTerm;
220.     }
222.     /**
223.      * Did this request force a refresh? Requests that set {@link WriteRequest#setRefreshPolicy(RefreshPolicy)} to
224.      * {@link RefreshPolicy#IMMEDIATE} will always return true for this. Requests that set it to {@link RefreshPolicy#WAIT_UNTIL} will
225.      * only return true here if they run out of refresh listener slots (see {@link IndexSettings#MAX_REFRESH_LISTENERS_PER_SHARD}).
226.      */
227.     public boolean forcedRefresh() {
228.         return forcedRefresh;
229.     }
231.     @Override
232.     public void setForcedRefresh(boolean forcedRefresh) {
233.         this.forcedRefresh = forcedRefresh;
234.     }
236.     /** returns the rest status for this response (based on {@link ShardInfo#status()} */
237.     @Override
238.     public RestStatus status() {
239.         return getShardInfo().status();
240.     }
242.     /**
243.      * Return the relative URI for the location of the document suitable for use in the {@code Location} header. The use of relative URIs is
244.      * permitted as of HTTP/1.1 (cf. https://tools.ietf.org/html/rfc7231#section-7.1.2).
245.      *
246.      * @param routing custom routing or {@code null} if custom routing is not used
247.      * @return the relative URI for the location of the document
248.      */
249.     public String getLocation(@Nullable String routing) {
250.         final String encodedIndex;
251.         final String encodedType;
252.         final String encodedId;
253.         final String encodedRouting;
254.         try {
255.             // encode the path components separately otherwise the path separators will be encoded
256.             encodedIndex = URLEncoder.encode(getIndex(), "UTF-8");
257.             encodedType = URLEncoder.encode(getType(), "UTF-8");
258.             encodedId = URLEncoder.encode(getId(), "UTF-8");
259.             encodedRouting = routing == null ? null : URLEncoder.encode(routing, "UTF-8");
260.         } catch (final UnsupportedEncodingException e) {
261.             throw new AssertionError(e);
262.         }
263.         final String routingStart = "?routing=";
264.         final int bufferSizeExcludingRouting = 3 + encodedIndex.length() + encodedType.length() + encodedId.length();
265.         final int bufferSize;
266.         if (encodedRouting == null) {
267.             bufferSize = bufferSizeExcludingRouting;
268.         } else {
269.             bufferSize = bufferSizeExcludingRouting + routingStart.length() + encodedRouting.length();
270.         }
271.         final StringBuilder location = new StringBuilder(bufferSize);
272.         location.append('/').append(encodedIndex);
273.         location.append('/').append(encodedType);
274.         location.append('/').append(encodedId);
275.         if (encodedRouting != null) {
276.             location.append(routingStart).append(encodedRouting);
277.         }
279.         return location.toString();
280.     }
282.     public void writeThin(StreamOutput out) throws IOException {
283.         super.writeTo(out);
284.         writeWithoutShardId(out);
285.     }
287.     @Override
288.     public void writeTo(StreamOutput out) throws IOException {
289.         super.writeTo(out);
290.         shardId.writeTo(out);
291.         writeWithoutShardId(out);
292.     }
294.     private void writeWithoutShardId(StreamOutput out) throws IOException {
295.         out.writeString(type);
296.         out.writeString(id);
297.         out.writeZLong(version);
298.         if (out.getVersion().onOrAfter(Version.V_6_0_0_alpha1)) {
299.             out.writeZLong(seqNo);
300.             out.writeVLong(primaryTerm);
301.         }
302.         out.writeBoolean(forcedRefresh);
303.         result.writeTo(out);
304.     }
306.     @Override
307.     public final XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
308.         builder.startObject();
309.         innerToXContent(builder, params);
310.         builder.endObject();
311.         return builder;
312.     }
314.     public XContentBuilder innerToXContent(XContentBuilder builder, Params params) throws IOException {
315.         ReplicationResponse.ShardInfo shardInfo = getShardInfo();
316.         builder.field(_INDEX, shardId.getIndexName());
317.         builder.field(_TYPE, type);
318.         builder.field(_ID, id).field(_VERSION, version).field(RESULT, getResult().getLowercase());
319.         if (forcedRefresh) {
320.             builder.field(FORCED_REFRESH, true);
321.         }
322.         builder.field(_SHARDS, shardInfo);
323.         if (getSeqNo() >= 0) {
324.             builder.field(_SEQ_NO, getSeqNo());
325.             builder.field(_PRIMARY_TERM, getPrimaryTerm());
326.         }
327.         return builder;
328.     }
330.     /**
331.      * Parse the output of the {@link #innerToXContent(XContentBuilder, Params)} method.
332.      *
333.      * This method is intended to be called by subclasses and must be called multiple times to parse all the information concerning
334.      * {@link DocWriteResponse} objects. It always parses the current token, updates the given parsing context accordingly
335.      * if needed and then immediately returns.
336.      */
337.     protected static void parseInnerToXContent(XContentParser parser, Builder context) throws IOException {
338.         XContentParser.Token token = parser.currentToken();
339.         ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser);
341.         String currentFieldName = parser.currentName();
342.         token = parser.nextToken();
344.         if (token.isValue()) {
345.             if (_INDEX.equals(currentFieldName)) {
346.                 // index uuid and shard id are unknown and can't be parsed back for now.
347.                 context.setShardId(new ShardId(new Index(parser.text(), IndexMetadata.INDEX_UUID_NA_VALUE), -1));
348.             } else if (_TYPE.equals(currentFieldName)) {
349.                 context.setType(parser.text());
350.             } else if (_ID.equals(currentFieldName)) {
351.                 context.setId(parser.text());
352.             } else if (_VERSION.equals(currentFieldName)) {
353.                 context.setVersion(parser.longValue());
354.             } else if (RESULT.equals(currentFieldName)) {
355.                 String result = parser.text();
356.                 for (Result r : Result.values()) {
357.                     if (r.getLowercase().equals(result)) {
358.                         context.setResult(r);
359.                         break;
360.                     }
361.                 }
362.             } else if (FORCED_REFRESH.equals(currentFieldName)) {
363.                 context.setForcedRefresh(parser.booleanValue());
364.             } else if (_SEQ_NO.equals(currentFieldName)) {
365.                 context.setSeqNo(parser.longValue());
366.             } else if (_PRIMARY_TERM.equals(currentFieldName)) {
367.                 context.setPrimaryTerm(parser.longValue());
368.             }
369.         } else if (token == XContentParser.Token.START_OBJECT) {
370.             if (_SHARDS.equals(currentFieldName)) {
371.                 context.setShardInfo(ShardInfo.fromXContent(parser));
372.             } else {
373.                 parser.skipChildren(); // skip potential inner objects for forward compatibility
374.             }
375.         } else if (token == XContentParser.Token.START_ARRAY) {
376.             parser.skipChildren(); // skip potential inner arrays for forward compatibility
377.         }
378.     }
380.     /**
381.      * Base class of all {@link DocWriteResponse} builders. These {@link DocWriteResponse.Builder} are used during
382.      * xcontent parsing to temporarily store the parsed values, then the {@link Builder#build()} method is called to
383.      * instantiate the appropriate {@link DocWriteResponse} with the parsed values.
384.      */
385.     public abstract static class Builder {
387.         protected ShardId shardId = null;
388.         protected String type = null;
389.         protected String id = null;
390.         protected Long version = null;
391.         protected Result result = null;
392.         protected boolean forcedRefresh;
393.         protected ShardInfo shardInfo = null;
394.         protected long seqNo = UNASSIGNED_SEQ_NO;
395.         protected long primaryTerm = UNASSIGNED_PRIMARY_TERM;
397.         public ShardId getShardId() {
398.             return shardId;
399.         }
401.         public void setShardId(ShardId shardId) {
402.             this.shardId = shardId;
403.         }
405.         public String getType() {
406.             return type;
407.         }
409.         public void setType(String type) {
410.             type =  StrUtil.isEmpty(type)?"_doc":type;;
411.         }
413.         public String getId() {
414.             return id;
415.         }
417.         public void setId(String id) {
418.             this.id = id;
419.         }
421.         public void setVersion(Long version) {
422.             this.version = version;
423.         }
425.         public void setResult(Result result) {
426.             this.result = result;
427.         }
429.         public void setForcedRefresh(boolean forcedRefresh) {
430.             this.forcedRefresh = forcedRefresh;
431.         }
433.         public void setShardInfo(ShardInfo shardInfo) {
434.             this.shardInfo = shardInfo;
435.         }
437.         public void setSeqNo(long seqNo) {
438.             this.seqNo = seqNo;
439.         }
441.         public void setPrimaryTerm(long primaryTerm) {
442.             this.primaryTerm = primaryTerm;
443.         }
445.         public abstract DocWriteResponse build();
446.     }
447. }

复制代码

写在最后

假如想要相识改的内容，可以找到官方源码对比下实现，然后本身DEBUG一下，
然后就可以知道Elasticsearch7和Elasticsearch8在连接时候的区别了。
假如要问为什么，答案就是可以本身动态创建索引，还可以指定字段类型，就是
这么香而已。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。