南天一梦N

一篇掌握Elasticsearch7.10集群搭建到实战

一、背景

二、内容概要

三、基础概念

四、ES版本选择

Elasticsearch版本选择

ES客户端SDK版本选择

五、Elasticsearch多租户

多租户下的架构

租户的识别和路由

六、ES 集群搭建

集群部署架构

单集群示例

多集群示例

ES集群搭建配置

安装中文分词插件 IK

七、ES SDK及增删改查Demo

八、ES管理工具

安装集群管理工具- Kibana

es-header插件安装使用

九、ES集群安全策略

X-pack安全策略开启及集群配置

十、ES运维

数据备份与恢复

索引重建

索引设置别名

十一、ES常用操作命令

十二、ES 相关资料

一、背景

鉴于公司接下来很多业务场景需要用到搜索引擎，之后负责进行调研, 比较早的时候用过solr，现在来看显得有点过时了，不过它依然还是有自己的优势比如查询效率、同步延迟等。各个云厂商也有搜索引擎但是作为小厂肯定是用不起，现在主流都是ES也只有这一个选择，不过ES也有不少坑，比如最少1s的查询延迟，假如你的业务不允许有1s的查询延迟，那你还是选择别的方案吧。

二、内容概要

elasticsearch版本选择对比，包括sdk的选择
elasticsearch多租户设计方案，逻辑隔离与物理隔
elasticsearch集群搭建，安全设置
elasticsearch 增删改查Demo及sdk的封装
kibana介绍与搭建
elasticsearch常见运维方法及操作命令

三、基础概念

Elasticsearch是一个开源的分布式搜索引擎，可以用来存储您的数据，然后进行快速的搜索。

Elasticsearch是面向文档的，与关系型数据库对比，在数据概念上有些区别：

一个业务数据在关系数据库中往往会建一个表，在ES 7.x++中是建一个索引 (indies)，无论是表还是索引都会包含一些字段。

数据库中一条记录往往称为一条记录用row来表示，在es中被称为一个文档document。在es中添加一条数据就是添加一个文档。

数据库中一个属性往往会叫做列column，在es中被称为一个field。

数据库创建表有标准的SQL语句，ES也有自己的创建索引语法，例如以下为创建一个名为 test001的索引，数据分成5片，一份副本，共有三个字段

PUT test001
{
    "settings": {
        "number_of_shards": 5,
        "number_of_replicas": 1
    },
    "mappings": {
        "properties": {
            "id": {
                "type": "long"
            },
            "name": {
                "type": "text",
                "analyzer": "ik_max_word"
            },
            "age": {
                "type": "integer"               
            }
        }
    }
}

四、ES版本选择

注：由于elasticsearch各版本差异较大，所以在调研及给出具体的方案前我们需要确定使用的es版本

通过大量资料搜索对比了对各个版本差异，最终选择7.10比较稳定的版本来使用。 es从5.x、6.x、7.x、8.x设计及sdk差异都比较大，5和6版本比较老了，与现在spring boot 2.x版本集成存在问题，8.x比较新才出一两年也有比较多的license限制，所以最终选择了7.10版本。

elasticsearch版本选择

结论：优先选择 7.10.0
原因对比如下

类型\版本	6.x	7.x	8.x	建议
Licence	Apache 2.0	7.0 ~ 7.10 Apache 2.0 7.11++ SSPL	SSPL	建议选择更友好的Apache2.0版本,sspl对于在云上想要让ES as a Service，将会面临es厂商的限制
云厂商支持程度	腾讯、阿里云均支持，华为不支持	腾讯云最高版 7.10.x 阿里云7.10.x，7.16.x 华为云7.6.x, 7.10.x	均不支持	各云厂商也主要在推广7.x版本，稳定性及占用率更高，建议选择7.x中的7.10.0版本
发版时间	初版2016	2019年	2021年底	建议选择 7.x版本，经历将近4年，稳定性已经经过验证，6.x和8.x一个太老一个太新
特性差异	/	集群配置简化，master选举进行了优化，能够避免集群脑裂问题; 索引创建已经去除了type，更加简化; 索引查询算法升级，查询性能有优化; 提供安全策略; Kibana更轻量化，更易用;	ES API进行了升级方便后续升级使用; 更加安全，es默认开启了一些安全功能; 新的搜索API 特性，比如支持NLP等;	7.x基本也能满足目前需求,稳定性也更有保障
Spring Boot兼容性	2.1 ~ 2.2版本对6.x支持	2.3 ~ 2.7版本对7.x支持	/	基于目前应用中使用的spring boot版本，只能选择 7.x版本

ES客户端SDK版本选择

结论：使用spring官方提供的spring-boot-es-starter

客户端	适用版本	优点	缺点	建议
TransportClient	5.x 6.x	启动速度快，轻量级，可创建极多连接，与应用程序解耦；推荐使用原生的，ES本身就很简单，灵活性很高	分发或查询数据速度较慢，不能获取指定节点数据，高版本已经废弃	不建议使用
JestClient	5.x 6.x 7.x	提供Restful API，原生ES API不具备；若ES集群使用不同的ES版本，使用原生ES API会有问题，而Jest不会；更安全（可以在Http层添加安全处理）；JestClient是ElasticSearch的Java HTTP Rest客户端； JestClient填补了 ElasticSearch缺少HttpRest接口客户端的空白; JestClient可以跨版本	18年已经停止更新，7.x、8.x版本兼容性存疑	不建议使用
RestClient low-level-rest-client	5.0++	基于Http Client 进行的简单封装，RestClient可以跨版本，支持到目前8.x所有版本。	HttpClient和Jsoup都不直接支持发送DELETE方法带参数的请求（官方高版本已经放弃使用）。使用成本较高	不推荐
high-level-rest-client	7.2.0 - 7.16.x	官方基于RestClient进行的封装，提供一系列API方便对ES的使用	在7.17版本后官方又废弃了	7部分版本推荐使用
New ElasticsearchClient	7.17++	为最新官方提供的版本	较高版本es适用	8.x官方推荐使用
spring-boot-es-starter	3.0++	spring官方封装的ES api，使用起来相对简单,也spring兼容性也能保障，教程也比较多。	需要与使用的es版本进行匹配	推荐使用

五、Elasticsearch多租户

es本身没有租户的能力，对es来说都是一个一个独立索引，这些索引默认都存储在一个es集群上，考虑后面ES as a Service，即作为PaaS能力来提供服务时，就不得不加入租户设计，这也是云时代iaas、paas、saas所面临的共同问题。通过调研市面上并无较多可参考的设计及直接可用的es多租户plugin，基于此需要自行设计支持。

多租户下的架构

多租户架构往往我们要提供逻辑隔离和物理隔离两种能力，根据需求并可以灵活定制某一租户是独享集群还是共享集群，当独享集群则是物理隔离，当共享集群时就是逻辑隔离，无论哪种方式都要做到部署架构能够低成本支持，应用层对集群无感；

租户的识别和路由

逻辑隔离代表着所有索引在同一个ES集群上，此时可以通过在索引上加一个tenant字段，通过字段隔离业务数据
物理隔离则可以前置一个负载均衡，比如使用Nginx来完成往不同的ES集群分发请求，不同的集群有不同的地址，应用发起请求时根据请求中的参数进行路由
- 考虑方便路由及管理，团队内可以定制租户及索引名统一命名规范，比如租户cod: tenantxx,文章索引名为article,完整索引名为：tenantxx_article

六、ES 集群搭建

注意

生产环境linux下Es 不能使用root启动，需要给es创建独立用户

集群部署架构

下面示例是以三个机器实例来搭建的，es集群搭建机器实例个数也要是单数避免选举master或脑裂问题。

单集群示例

集群每个节点都可以设置为可参与master选举及是否是数据节点

多集群示例

集群访问规范

出于安全及后续维护综合考虑，es集群对外提供访问地址最好是一个域名，这样能避免ip到处暴露，也避免IP较高频率变化而导致系统经常升级。

ES集群搭建配置

es官方下载地址，es和kibana尽量下载同一版本

elasticsearch各版本下载地址

https://www.elastic.co/cn/downloads/past-releases#elasticsearch

kibana (es的可视化管理工具)

https://www.elastic.co/cn/downloads/past-releases/#kibana

启动前需要修改一些配置，先在一台上进行修改运行验证，待验证通过后，再copy到其它实例上

集群搭建前必读（以下配置验证于es7.10版本，不同的版本差异比较大请认准版本）

1、先搭建单个节点

先找任一个节点修改elasticsearch.yml，并添加以下配置（此时不要添加集群和证书配置）

path.data: /opt/data
path.logs: /opt/logs

#http访问端口，程序或kibana使用
http.port: 9200

xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true

2、启动ES

观察启动是否ok，若ok进行第三步

./bin/elasticsearch

3、设置安全账号信息（ES要启动状态）

执行以下命令，给各账号设置密码，整个集群只需要设置一次即可
警告：设置账户密码切记要在单实例非集群模式时配置，不能添加任何集群的配置，否则会设置失败
```
bin/elasticsearch-setup-passwords interactive
```

4、添加配置集群配置信息

集群搭建需要开启安全，开启安全需要用到证书，证书生成参考【ES集群安全策略步骤进行生成】，生成后进行以下配置
elasticsearch.yml加入以下配置

#数据和日志存储路径
path.data: /opt/data
path.logs: /opt/logs
#数据备份和恢复使用，可以一到多个目录
path.repo: ["/opt/backup/es", "/opt/backup/es1"]

#http访问端口，程序或kibana使用
http.port: 9200

#集群名称
cluster.name: es001
#节点名，每个节点名不能重复
node.name: node1

#是否可以参与选举主节点
node.master: true
#是否是数据节点
node.data: true

#允许访问的ip，4个0的话则允许任何ip进行访问
network.host: 0.0.0.0


#es各节点通信端口
transport.tcp.port: 9300

#集群每个节点IP地址。
discovery.seed_hosts: ["xxx.xx.xx.xx:9300", "xx.xx.xx:9300", "xx.xx.xx:9300"]                  
#es7.x新增的配置，初始化一个新的集群时需要此配置来选举master
cluster.initial_master_nodes: ["node1", "node2", "node3"]  


#配置是否压缩tcp传输时的数据，默认为false，不压缩
transport.tcp.compress: true
# 是否支持跨域,es-header插件使用
http.cors.enabled: true
# *表示支持所有域名跨域访问
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization,X-Requested-With,Content-Type,Content-Length

#集群模式开启安全 https://www.elastic.co/guide/en/elasticsearch/reference/7.17/security-minimal-setup.html
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.license.self_generated.type: basic
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: certs/elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: certs/elastic-certificates.p12


#默认为1s，指定了节点互相ping的时间间隔。
discovery.zen.fd.ping_interval: 1s
#默认为30s，指定了节点发送ping信息后等待响应的时间，超过此时间则认为对方节点无响应。
discovery.zen.fd.ping_timeout: 30s
#ping失败后重试次数，超过此次数则认为对方节点已停止工作。
discovery.zen.fd.ping_retries: 3

5 、jvm.options

设置占用的内存，根据机器配置设置，es还是需要比较多的内存

-Xms6g     
-Xmx6g

如果在linux下启动出现以错时需要修改linux系统配置

max virtual memory areas vm.max_map_count [65530] is too low, increase to at

sudo vim /etc/sysctl.conf
 
#添加参数
vm.max_map_count = 262144

#重新加载配置
sysctl -p

6、配置集群其它节点

重复1、2、4、5等步骤，然后启动其它节点ES，看是否成功。搭建第2个节点时可以直接把第一个节点的配置和证书全copy过来。

注意：启动第二个节点后最好先验证节点是否已经加到集群里了，验证方法有以下两种：

使用系统命令查看集群节点数量

curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cluster/health?pretty"

创建一个索引看集群中每个节点索引数据
- 1、可以在任间一个节点执行创建索引命令
```
curl -XPUT -u elastic:elastic123 "http://127.0.0.1:9200/test-index"
```
- 2、查看所有节点索引是否一致
```
curl -XGET -u elastic:elastic123  "http://localhost:9200/_cat/indices?pretty"
```

在每个节点都执行以上命令看所有节点是否返回一致，如果集群搭建正常，在任意一个节点创建索引后都会自动同步到其它节点，如果返回不一致则认为集群搭建的是有问题的；

7、关闭索引自动创建

待es集群搭建完启动成功后，执行以下命令可以关闭索引自动创建功能，当然也可以不关闭，不关闭的话es sdk保存数据时候如果索引不存在则会自动创建索引，尽量还是关闭由专门负责人统一来管理索引
```
PUT _cluster/settings
{
  "persistent": {
    "action.auto_create_index": "false" 
  }
}
```
PUT _cluster/settings { "persistent": { "action.auto_create_index": "false" } }

注：如果后续装x-pak,可能需要修改 action.auto_create_index 值

8、修改es集群索引默认分片数

PUT _template/template_http_request_record
{
    "index_patterns": [
        "*"
    ],
    "settings": {
        "number_of_shards": 5,
        "number_of_replicas": 1
    }
}

index_patterns = * 代表对所有索引生效

number_of_shards 是索引主分片数.

number_of_replicas 是备份数量.

注： 7.x版本默认是1分片1备份，在集群3个节点情况设置为5分片较合适

ES集群模式数据分布原理

一个ES集群至少有一个节点，一个节点就是一个 elasricsearch 进程，每个节点可以有多个索引，如果创建索引时设置为5个分片，一个副本，那么索引数据将会均匀划分到 5 个分片上 (primary shard，又称主分片)，每个分片有一个副本(replica shard，又称复制分片)。为了保证数据的稳定性es会把某个分片及副本存储在不同的实例上。

集群索引分片策略

合理设置分片意义
- es是一个分式式的搜索引擎，ES中默认为每个索引创建5个分片，每个分片提供一个备份。如果分片过小，当索引数据量非常大的话，每个分片上的数据就会比较多，导致检索时候效率较低，反之分片过多各节点之间的数据同步会过多消耗集群资源、检索时多分片数据归并也会影响效率，所以需要有一些标准来设置合理的分片避免上述问题。

分片设置官方建议

1、分片过小会导致段过小，进而致使开销增加。您要尽量将分片的平均大小控制在至少几 GB 到几十 GB 之间。
对时序型数据用例而言，分片大小通常介于 20GB 至 40GB 之间。

2、由于单个分片的开销取决于段数量和段大小，所以通过 forcemerge 操作强制将
较小的段合并为较大的段能够减少开销并改善查询性能。理想状况下，
应当在索引内再无数据写入时完成此操作。请注意：这是一个极其耗费资源的操作，
所以应该在非高峰时段进行。 

3、每个节点上可以存储的分片数量与可用的堆内存大小成正比关系，但是 Elasticsearch并未
强制规定固定限值。这里有一个很好的经验法则：确保对于节点上已配置的每个 GB，将分片数量
保持在 20 以下。如果某个节点拥有 30GB 的堆内存，那其最多可有 600 个分片，但是在此限值范围内，
您设置的分片数量越少，效果就越好。一般而言，这可以帮助集群保持良好的运行状态。
（编者按：从 8.3 版开始，我们大幅减小了每个分片的堆使用量，
因此对本博文中的经验法则也进行了相应更新。请按照以下提示了解 8.3+ 版本的 
Elasticsearch。）

其它网上使用经验
- 每个分片的数据量不超过最大JVM堆空间设置，一般不超过32G。如果一个索引大概500G，那分片大概在16个左右比较合适。
- 单个索引分片个数一般不超过节点数的3倍，推荐是1.5 ~ 3倍之间。假如一个集群3个节点，根据索引数据量大小分片数在5-9之间比较合适。
- 主分片、副本和节点数，分配时也可以参考以下关系：节点数<= 主分片数 * （副本数 +1 ）

结论
- 集群能承受的分片数
  
  单实例推荐最大分片数： (8G-2G-0.5G) * 20 = 110 个分片
  - 依目前3个4C8G实例规格举例来说明：
  - ```
  单实例推荐最大分片数： (8G-2G-0.5G) * 20 = 110 个分片
```
- 2G留给操作系统及其它软件内存使用，0.5G是留给ES本身做计算所需的内存资源。
  所以当前集群可以承载110 * 3 = 330 个分片，假如每个索引5个分片，整个集群可以容纳 330 / 5 = 66 个索引
  - 单个索引分片数
    - 依上面经验来计算3个节点的集群，索引分片为5-9个比较合适

安装中文分词插件 IK

ES 底层使用Lucene来构建的索引，Lucene历来对中文分词一直支持的不够好，所以需要使用更智能的中文分词。基于Lucene支持自定义分词的能力，ES也以Plugin方式提供了安装自定义分词的能力。目前使用最广泛的中文分词是IK,也提供了ES版本，直接安装使用即可。

IK分词git，上面有安装使用说明

https://github.com/medcl/elasticsearch-analysis-ik/tree/v7.10.0

安装命令-注意版本是否正确，一定要和es版本匹配

./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.10.0/elasticsearch-analysis-ik-7.10.0.zip

测试分词效果,需要在kibana控制台测试

POST _analyze
{
  "analyzer": "ik_max_word",
  "text":"中国河南南阳"
}

七、ES SDK及增删改查

完整代码可以从github上下载

https://github.com/caizi12/my-elasticsearch-starter.git

代码说明

封装了易于使用的elasticsearch starter，使用时可以先把代码Deploy到私有仓库中，然后应用程序中依赖使用，如果没有私有仓库可以把代码copy到应用中使用。

Deploy到仓库后使用方式

1、应用添加依赖


  com.my.es
  elasticsearch-starter
  1.0.0-SNAPSHOT

2、application.properties 添加es链接配置

#es链接地址
spring.elasticsearch.uris=http://localhost:9200

#es账号密码，根据实际填写
spring.elasticsearch.username=elastic
spring.elasticsearch.password=123456
#可省配置：连接es集群超时参数，默认毫秒
spring.elasticsearch.connection-timeout=300
spring.elasticsearch.read-timeout=300

3、Demo，（更多示例可以看单元测试部分）



@SpringBootTest
public class MyEsServiceTest {
    @Autowired
    private MyEsService myEsService;

    @Test
    public void delIndex() {
        boolean result = myEsService.deleteIndexIfExist(Student.class);
        Assert.assertTrue(result);
    }

    @Test
    public void delIndexDoc() {
        String result = myEsService.delIndexDoc("3007", Student.class);
        System.out.println("delIndexDoc:" + Student.class.getName());
    }


    @Test
    public void updateMapping() {
        boolean result = myEsService.updateIndexMapping(Student.class);
        Assert.assertTrue(result);
    }


    @Test
    public void updateIndexMapping() {
        boolean result = myEsService.updateIndexMapping(Shop.class);
        Assert.assertTrue(result);
    }

    @Test
    public void createIndex() {
        boolean exist = myEsService.existIndex(Student.class);
        boolean result = false;
        if (!exist) {
            result = myEsService.createIndexIfNotExist(Student.class);
        } else {
            System.out.println("index exist:" + Student.class.getName());
        }
        Assert.assertTrue(result);
    }


    @Test
    public void addIndexDoc() {
        Student student = new Student(1000, "张三", "测试索引添加", "哈哈", "三年二班刘", 10, new Date(), null);
        String documentId = myEsService.addIndexDoc(student);
        System.out.println("addIndexDoc result:" + documentId);
        Assert.assertNotNull(documentId);
    }
}

ES SDK封装代码示例

接口定义

package com.my.elasticsearch;

import java.util.List;

import javax.annotation.Nullable;

import com.my.elasticsearch.model.MyEsSearchRequest;
import org.elasticsearch.index.query.QueryBuilder;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;

/**
 * es服务接口，该接口提供对es的增删改查操作
 *
 * @authro nantian
 * @date 2022-10-08 15:19
 */
public interface MyEsService {
    /**
     * 判断索引是否存在, 文档需标注@Document注解
     *
     * @param clazz
     * @return
     */
    boolean existIndex(Class clazz);

    /**
     * 判断索引是否存在, 文档需标注@Document注解
     *
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    boolean existIndex(Class clazz, boolean nonTenantMode);

    /**
     * 创建索引并设置mapping,setting信息
     * 文档需标注@Document注解、包含@Id注解，其它属性字段需要添加@Field注解
     *
     * @param clazz
     * @return
     */
    boolean createIndexIfNotExist(Class clazz);

    /**
     * 创建索引并设置mapping,setting信息
     * 文档需标注@Document注解、包含@Id注解，其它属性字段需要添加@Field注解
     *
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    boolean createIndexIfNotExist(Class clazz, boolean nonTenantMode);

    /**
     * 更新索引mapping信息，已存在的索引重复调用新加的字段会自动更新上去，老字段不会变化
     *
     * @param clazz
     * @return
     */
    boolean updateIndexMapping(Class clazz);

    /**
     * 更新索引mapping信息，已存在的索引重复调用新加的字段会自动更新上去，老字段不会变化
     *
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    boolean updateIndexMapping(Class clazz, boolean nonTenantMode);

    /**
     * 删除索引，业务应用中不建议用，如果有必要联系管理员在Kibana控台进行操作
     *
     * @param clazz
     * @return
     */
    boolean deleteIndexIfExist(Class clazz);

    /**
     * 删除索引，业务应用中不建议用，如果有必要联系管理员在Kibana控台进行操作
     *
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    boolean deleteIndexIfExist(Class clazz, boolean nonTenantMode);

    /**
     * 判断一个文档是否存在
     *
     * @param clazz
     * @param docId
     * @return
     */
    boolean existDocById(Class clazz, String docId);

    /**
     * 判断一个文档是否存在
     *
     * @param clazz
     * @param docId
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    boolean existDocById(Class clazz, String docId, boolean nonTenantMode);

    /**
     * 添加一个数据到索引中，推荐使用@addIndexDoc(T model)
     *
     * @param indexName 索引名
     * @param model     索引数据，注解@Id的字段值不允许为空
     * @return 文档ID
     */
     String addIndexDoc(String indexName, T model);

    /**
     * 添加一个数据到索引中，推荐使用@addIndexDoc(T model)
     *
     * @param indexName     索引名
     * @param model         索引数据，注解@Id的字段值不允许为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return 文档ID
     */
     String addIndexDoc(String indexName, T model, boolean nonTenantMode);

    /**
     * 添加一个数据到索引中
     * 会自动获取类上的@Document(indexName)属性当索引名
     *
     * @param model 文档数据，注解@Id的字段值不允许为空
     * @return
     */
     String addIndexDoc(T model);

    /**
     * 添加一个数据到索引中
     * 会自动获取类上的@Document(indexName)属性当索引名
     *
     * @param model         文档数据，注解@Id的字段值不允许为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     String addIndexDoc(T model, boolean nonTenantMode);

    /**
     * 添加一个数据到索引中，指定数据版本号
     *
     * @param model   es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version 数据版本号
     * @return
     */
     String saveIndexDoc(T model, Long version);

    /**
     * 添加一个数据到索引中，指定数据版本号
     *
     * @param model         es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version       数据版本号
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     String saveIndexDoc(T model, Long version, boolean nonTenantMode);

    /**
     * 添加一个数据到索引中
     * 会自动获取类上的@Document(indexName)属性当索引名
     * 指定数据版本号
     *
     * @param indexName 索引名称
     * @param model     es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version   数据版本号
     * @return
     */
     String saveIndexDoc(String indexName, T model, Long version);

    /**
     * 添加一个数据到索引中
     * 会自动获取类上的@Document(indexName)属性当索引名
     * 指定数据版本号
     *
     * @param indexName     索引名称
     * @param model         es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version       数据版本号
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     String saveIndexDoc(String indexName, T model, Long version, boolean nonTenantMode);

    /**
     * 批量添加索引，推荐使用@bulkAddIndexDoc(Class clazz, List docList)
     *
     * @param indexName
     * @param docList
     * @return
     */
     List bulkAddIndexDoc(String indexName, List docList);

    /**
     * 批量添加索引，推荐使用@bulkAddIndexDoc(Class clazz, List docList)
     *
     * @param indexName
     * @param docList
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     List bulkAddIndexDoc(String indexName, List docList, boolean nonTenantMode);

    /**
     * 批量添加索引
     *
     * @param indexName 索引名称
     * @param docList   es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @return
     */
     List bulkSaveIndexDoc(String indexName, List docList);

    /**
     * 批量添加索引
     *
     * @param indexName     索引名称
     * @param docList       es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     List bulkSaveIndexDoc(String indexName, List docList, boolean nonTenantMode);

    /**
     * 批量添加索引，会自动获取类上的 @Document(indexName)属性当索引名
     *
     * @param clazz
     * @param docList
     * @return
     */
     List bulkAddIndexDoc(Class clazz, List docList);

    /**
     * 批量添加索引，会自动获取类上的 @Document(indexName)属性当索引名
     *
     * @param clazz
     * @param docList
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     List bulkAddIndexDoc(Class clazz, List docList, boolean nonTenantMode);

    /**
     * 批量添加索引
     *
     * @param clazz   会自动获取类上的 @Document(indexName)属性当索引名
     * @param docList es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @return
     */
     List bulkSaveIndexDoc(Class clazz, List docList);

    /**
     * 批量添加索引
     *
     * @param clazz         会自动获取类上的 @Document(indexName)属性当索引名
     * @param docList       es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     List bulkSaveIndexDoc(Class clazz, List docList, boolean nonTenantMode);

    /**
     * 更新文档，会自动获取类上的@Document(indexName)属性当索引名
     *
     * @param model 注解@Id的字段值不允许为空
     * @return
     */
     UpdateResponse.Result updateDoc(T model);

    /**
     * 更新文档，会自动获取类上的@Document(indexName)属性当索引名
     *
     * @param model         注解@Id的字段值不允许为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     UpdateResponse.Result updateDoc(T model, boolean nonTenantMode);

    /**
     * 批量更新文档，会自动获取类上的@Document(indexName)属性当索引名
     *
     * @param clazz
     * @param    注解@Id的字段值不允许为空
     * @return
     */
     List bulkUpdateDoc(Class clazz, List modelList);

    /**
     * 批量更新文档
     *
     * @param clazz
     * @param          注解@Id的字段值不允许为空
     * @param bulkOptions
     * @return
     */
     List bulkUpdateDoc(Class clazz, List modelList, BulkOptions bulkOptions);

    /**
     * 根据ID删除一个索引文档
     *
     * @param id
     * @param clazz
     * @return
     */
    String delIndexDoc(String id, Class clazz);

    /**
     * 根据ID删除一个索引文档
     *
     * @param id
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    String delIndexDoc(String id, Class clazz, boolean nonTenantMode);

    /**
     * 批量删除索引
     *
     * @param clazz
     * @param ids
     * @return
     */
    List bulkDelIndexDoc(Class clazz, List ids);

    /**
     * 批量删除索引
     *
     * @param clazz
     * @param ids
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    List bulkDelIndexDoc(Class clazz, List ids, boolean nonTenantMode);

    /**
     * 删除一个索引文档，会自动从类上获取注解为@Id属性的value当作ID
     *
     * @param model
     * @param 
     * @return
     */
     String delIndexDoc(T model);

    /**
     * 删除一个索引文档，会自动从类上获取注解为@Id属性的value当作ID
     *
     * @param model
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     String delIndexDoc(T model, boolean nonTenantMode);

    /**
     * @param docId
     * @param tClass
     * @param 
     * @return
     */
     T findById(String docId, Class tClass);

    /**
     * @param docId
     * @param clazz
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @param 
     * @return
     */
     T findById(String docId, Class clazz, boolean nonTenantMode);

    /**
     * 根据ID批量查询
     *
     *  使用id查询数据实时性更好
     *
     * @param indexName
     * @param clazz
     * @param docIdList
     * @param nonTenantMode
     * @param 
     * @return
     */
      List findByIds(String indexName, Class clazz, List docIdList, boolean nonTenantMode) ;
      List findByIds(Class clazz, List docIdList) ;
      List findByIds(Class clazz, List docIdList,boolean nonTenantMode) ;


    /**
     * 更丰富灵活的索引查询，开放spring-boot-es-starter原生NativeSearchQueryBuilder
     *
     * @param clazz        自动获取类上的@Document(indexName)属性当索引名
     * @param queryBuilder
     * @return
     */
     SearchHits search(Class clazz, NativeSearchQueryBuilder queryBuilder);

    /**
     * 更丰富灵活的索引查询，开放spring-boot-es-starter原生NativeSearchQueryBuilder
     *
     * @param clazz         自动获取类上的@Document(indexName)属性当索引名
     * @param queryBuilder
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     SearchHits search(Class clazz, NativeSearchQueryBuilder queryBuilder, boolean nonTenantMode);

    /**
     * 封装查询对象，简化NativeSearchQueryBuilder构造过程
     *
     * @param clazz   自动获取类上的@Document(indexName)属性当索引名
     * @param request
     * @return
     */
     SearchHits search(Class clazz, MyEsSearchRequest request);

    /**
     * 封装查询对象，简化NativeSearchQueryBuilder构造过程
     *
     * @param clazz         自动获取类上的@Document(indexName)属性当索引名
     * @param request
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     SearchHits search(Class clazz, MyEsSearchRequest request, boolean nonTenantMode);

    /**
     * 精确查询类场景推荐使用，es不会计算文档相关性分值，性能更好
     *
     * @param clazz         自动获取类上的@Document(indexName)属性当索引名
     * @param filterBuilder
     * @param pageable
     * @return
     */
     SearchHits searchByFilter(Class clazz, QueryBuilder filterBuilder, @Nullable Pageable pageable);

    /**
     * 精确查询类场景推荐使用，es不会计算文档相关性分值，性能更好
     *
     * @param clazz         自动获取类上的@Document(indexName)属性当索引名
     * @param filterBuilder
     * @param pageable
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     SearchHits searchByFilter(Class clazz, QueryBuilder filterBuilder, @Nullable Pageable pageable, boolean nonTenantMode);

    /**
     * 标题或文章内容检索类场景推荐使用，es会计算文档相关性，并按相关性自动排序
     *
     * @param clazz
     * @param queryBuilder
     * @param pageable
     * @return
     */
     SearchHits search(Class clazz, QueryBuilder queryBuilder, @Nullable Pageable pageable);

    /**
     * 标题或文章内容检索类场景推荐使用，es会计算文档相关性，并按相关性自动排序
     *
     * @param clazz
     * @param queryBuilder
     * @param pageable
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     SearchHits search(Class clazz, QueryBuilder queryBuilder, @Nullable Pageable pageable, boolean nonTenantMode);

    /**
     * 索引数据查询
     *
     * @param clazz         索引类
     * @param queryBuilder
     * @param filterBuilder
     * @return
     */
     SearchHits search(Class clazz, QueryBuilder queryBuilder, QueryBuilder filterBuilder, @Nullable Pageable pageable);

    /**
     * 索引数据查询
     *
     * @param clazz         索引类
     * @param queryBuilder
     * @param filterBuilder
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
     SearchHits search(Class clazz, QueryBuilder queryBuilder, QueryBuilder filterBuilder, @Nullable Pageable pageable, boolean nonTenantMode);

}

实现

package com.my.elasticsearch.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import com.my.elasticsearch.MyEsService;
import com.my.elasticsearch.cache.EsIndexNameCache;
import com.my.elasticsearch.util.EsReflectUtils;
import com.my.elasticsearch.util.EsTenantUtil;
import com.my.elasticsearch.model.MyEsSearchRequest;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
import org.springframework.data.elasticsearch.core.MultiGetItem;
import org.springframework.data.elasticsearch.core.MyRestIndexTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.index.Settings;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.FetchSourceFilter;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.IndexQueryBuilder;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.StringQuery;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

/**
 * es 公共组件服务实现
 *
 *  该实现提供了租户也非租户模式，租户模式会给索引名前自动加租户code前缀，如果不需要可以进行修改
 *
 * @authro nantian
 * @date 2022-10-08 15:19
 */
public class MyEsServiceImpl implements MyEsService {
    private static ObjectMapper objectMapper;
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    private static final String PROPERTIES_KEY = "properties";

    public MyEsServiceImpl(ElasticsearchRestTemplate elasticsearchRestTemplate) {
        this.elasticsearchRestTemplate = elasticsearchRestTemplate;
    }

    static {
        //JavaTimeModule timeModule = new JavaTimeModule();
        //timeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
        //timeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
         设置NULL值不参与序列化
        objectMapper = new ObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //.registerModule(timeModule);
    }

    /**
     * 根据使用的租户模式，决定是否对索引名添加租户标识
     *
     * @param index
     * @return
     */
    private String convertTenantIndex(String index) {
        return EsTenantUtil.getTenantIndex(index);
    }

    /**
     * 构建操作es的索引类
     *
     * @param index
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    private IndexCoordinates buildIndexCoordinates(String index, boolean nonTenantMode) {
        if (!nonTenantMode) {
            index = convertTenantIndex(index);
        }
        return IndexCoordinates.of(index);
    }

    private IndexCoordinates buildIndexCoordinates(Class clazz) {
        return buildIndexCoordinates(clazz, false);
    }

    private IndexCoordinates buildIndexCoordinates(Class clazz, boolean nonTenantMode) {
        if (!nonTenantMode) {
            return IndexCoordinates.of(convertTenantIndex(getEsIndexName(clazz)));
        }
        return IndexCoordinates.of(getEsIndexName(clazz));
    }

    /**
     * 根据类@Document(indexName)属性获取索引名
     *
     * @param clazz
     * @return
     */
    private String getEsIndexName(Class clazz) {
        return EsIndexNameCache.get(clazz);
    }

    /**
     * 判断索引是否存在
     *
     * @param indexName     索引名称
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    public boolean existIndex(String indexName, boolean nonTenantMode) {
        if (StringUtils.isNotEmpty(indexName)) {
            return elasticsearchRestTemplate.indexOps(buildIndexCoordinates(indexName, nonTenantMode)).exists();
        }
        return Boolean.FALSE;
    }

    /**
     * 判断索引是否存在
     *
     * @param clazz
     * @return
     */
    @Override
    public boolean existIndex(Class clazz) {
        return existIndex(clazz, false);
    }

    @Override
    public boolean existIndex(Class clazz, boolean nonTenantMode) {
        if (clazz != null) {
            return existIndex(getEsIndexName(clazz), nonTenantMode);
        }
        return Boolean.FALSE;
    }

    /**
     * 索引不存在时创建索引[无分片及mapping信息,暂不开放使用]
     *
     * @param indexName 索引名称
     * @return 是否创建成功
     */
    private boolean createIndexIfNotExist(String indexName) {
        return createIndexIfNotExist(indexName, false);
    }

    /**
     * 索引不存在时创建索引[无分片及mapping信息,暂不开放使用]
     *
     * @param indexName     索引名称
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return 是否创建成功
     */
    private boolean createIndexIfNotExist(String indexName, boolean nonTenantMode) {
        if (!existIndex(indexName, nonTenantMode)) {
            return elasticsearchRestTemplate.indexOps(buildIndexCoordinates(indexName, nonTenantMode)).create();
        }
        return Boolean.FALSE;
    }

    /**
     * 索引不存在时创建索引并设置分片及mapping信息
     *
     * @param clazz 索引类信息
     * @return 是否创建成功
     */
    @Override
    public boolean createIndexIfNotExist(Class clazz) {
        return createIndexIfNotExist(clazz, false);
    }

    @Override
    public boolean createIndexIfNotExist(Class clazz, boolean nonTenantMode) {
        boolean result = existIndex(clazz, nonTenantMode);
        if (!result) {
            //不能直接用createWithMapping，会漏掉租户信息，改写索引类上租户实现比较复杂
            //elasticsearchRestTemplate.indexOps(clazz).createWithMapping();
            MyRestIndexTemplate esRestIndexTemplate = new MyRestIndexTemplate(elasticsearchRestTemplate, clazz);
            Document document = esRestIndexTemplate.createMapping();
            Settings settings = esRestIndexTemplate.createSettings();

            return esRestIndexTemplate.doCreate(buildIndexCoordinates(clazz, nonTenantMode), settings, document);
        }
        return Boolean.FALSE;
    }

    /**
     * 更新索引字段，会自动获取类上的索引注解信息进行更新索引mapping，已存在的字段不会更新
     *
     * @param clazz
     * @return
     */
    @Override
    public boolean updateIndexMapping(Class clazz) {
        return updateIndexMapping(clazz, false);
    }

    @Override
    public boolean updateIndexMapping(Class clazz, boolean nonTenantMode) {
        boolean result = existIndex(clazz, nonTenantMode);
        if (result) {
            MyRestIndexTemplate esRestIndexTemplate = new MyRestIndexTemplate(elasticsearchRestTemplate, clazz);
            Document document = esRestIndexTemplate.createMapping();
            return esRestIndexTemplate.doPutMapping(buildIndexCoordinates(clazz, nonTenantMode), document);
        }
        return Boolean.FALSE;
    }

    /**
     * 索引存在删除索引
     *
     * @param indexName 索引名称
     * @return 是否删除成功
     */
    public boolean deleteIndexIfExist(String indexName) {
        return deleteIndexIfExist(indexName, false);
    }

    /**
     * 索引存在删除索引
     *
     * @param indexName 索引名称
     * @return 是否删除成功
     */
    public boolean deleteIndexIfExist(String indexName, boolean nonTenantMode) {
        if (existIndex(indexName, nonTenantMode)) {
            return elasticsearchRestTemplate.indexOps(buildIndexCoordinates(indexName, nonTenantMode)).delete();
        }
        return Boolean.FALSE;
    }

    /**
     * 索引存在删除索引
     *
     * @param clazz 索引名称
     * @return 是否删除成功
     */
    @Override
    public boolean deleteIndexIfExist(Class clazz) {
        if (existIndex(clazz)) {
            return deleteIndexIfExist(getEsIndexName(clazz));
        }
        return Boolean.FALSE;
    }

    @Override
    public boolean deleteIndexIfExist(Class clazz, boolean nonTenantMode) {
        if (existIndex(clazz, nonTenantMode)) {
            return deleteIndexIfExist(getEsIndexName(clazz), nonTenantMode);
        }
        return Boolean.FALSE;
    }

    /**
     * 新增索引文档，根据类上的@Document获取索引名
     *
     * @param model elasticsearch文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @return 文档ID
     */
    @Override
    public  String addIndexDoc(T model) {
        return addIndexDoc(getEsIndexName(model.getClass()), model);
    }

    @Override
    public  String addIndexDoc(T model, boolean nonTenantMode) {
        return addIndexDoc(getEsIndexName(model.getClass()), model, nonTenantMode);
    }

    /**
     * 新增文档,指定索引名
     *
     * @param indexName 索引名称
     * @param model     es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @return 文档ID
     */
    @Override
    public  String addIndexDoc(String indexName, T model) {
        return addIndexDoc(indexName, model, false);
    }

    @Override
    public  String addIndexDoc(String indexName, T model, boolean nonTenantMode) {
        Assert.notNull(indexName, "addIndexDoc elasticsearch indexName is null");
        Assert.notNull(model, "addIndexDoc document is null");
        return elasticsearchRestTemplate.index(
                new IndexQueryBuilder().withId(getDocumentIdValue(model)).withObject(model).build(),
                buildIndexCoordinates(indexName, nonTenantMode));
    }

    /**
     * 保存文档，指定数据版本号
     *
     * @param model   es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version 数据版本号
     * @param 
     * @return
     */
    @Override
    public  String saveIndexDoc(T model, Long version) {
        return saveIndexDoc(model, version, false);
    }

    @Override
    public  String saveIndexDoc(T model, Long version, boolean nonTenantMode) {
        return saveIndexDoc(getEsIndexName(model.getClass()), model, version, nonTenantMode);
    }

    /**
     * 保存文档，指定索引名和数据版本号
     *
     * @param indexName 索引名称
     * @param model     es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version   数据版本号
     * @return 文档ID
     */
    @Override
    public  String saveIndexDoc(String indexName, T model, Long version) {
        return saveIndexDoc(indexName, model, version, false);
    }

    /**
     * 保存文档，指定索引名和数据版本号
     *
     * @param indexName     索引名称
     * @param model         es文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param version       数据版本号
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return 文档ID
     */
    @Override
    public  String saveIndexDoc(String indexName, T model, Long version, boolean nonTenantMode) {
        Assert.notNull(indexName, "addIndexDoc elasticsearch indexName is null");
        Assert.notNull(model, "addIndexDoc document is null");
        return elasticsearchRestTemplate.index(
                new IndexQueryBuilder().withId(getDocumentIdValue(model)).withVersion(version).withObject(model).build(),
                buildIndexCoordinates(indexName, nonTenantMode));
    }

    @Override
    public  List bulkAddIndexDoc(Class clazz, List docList) {
        return bulkAddIndexDoc(getEsIndexName(clazz), docList);
    }

    @Override
    public  List bulkAddIndexDoc(Class clazz, List docList, boolean nonTenantMode) {
        return bulkAddIndexDoc(getEsIndexName(clazz), docList, nonTenantMode);
    }

    @Override
    public  List bulkSaveIndexDoc(Class clazz, List docList) {
        return bulkSaveIndexDoc(clazz, docList, false);
    }

    @Override
    public  List bulkSaveIndexDoc(Class clazz, List docList, boolean nonTenantMode) {
        return bulkSaveIndexDoc(getEsIndexName(clazz), docList, nonTenantMode);
    }

    /**
     * 批量新增文档
     *
     * @param indexName 索引名称
     * @param docList   es文档集合; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @return 文档ID
     */
    public  List bulkAddIndexDoc(String indexName, List docList) {
        return bulkAddIndexDoc(indexName, docList, false);
    }

    /**
     * 批量新增文档
     *
     * @param indexName     索引名称
     * @param docList       es文档集合; 文档需标注@Document注解、包含@Id注解字段, 且@Id注解标注的文档ID字段值不能为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return 文档ID
     */
    @Override
    public  List bulkAddIndexDoc(String indexName, List docList, boolean nonTenantMode) {
        Assert.notNull(indexName, "bulkAddIndexDoc elasticsearch indexName is null");
        Assert.notNull(docList, "bulkAddIndexDoc document is null");

        List indexQueries = new ArrayList<>();
        docList.forEach(doc ->
                indexQueries.add(new IndexQueryBuilder().withId(getDocumentIdValue(doc)).withObject(doc).build()));

        return elasticsearchRestTemplate.bulkIndex(indexQueries, buildIndexCoordinates(indexName, nonTenantMode));
    }

    /**
     * 批量新增文档
     *
     * @param indexName 索引名称
     * @param docList   es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @param 
     * @return
     */
    @Override
    public  List bulkSaveIndexDoc(String indexName, List docList) {
        return bulkSaveIndexDoc(indexName, docList, false);
    }

    /**
     * 批量新增文档
     *
     * @param indexName     索引名称
     * @param docList       es文档集合; 文档需标注@Document注解、包含@Id、@Version注解字段, 且@Id注解标注的文档ID字段值不能为空、@Version注解标注的文档数据版本字段值不能为空
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return
     */
    @Override
    public  List bulkSaveIndexDoc(String indexName, List docList, boolean nonTenantMode) {
        Assert.notNull(indexName, "bulkAddIndexDoc elasticsearch indexName is null");
        Assert.notNull(docList, "bulkAddIndexDoc document is null");

        // 验证是否传version值
        docList.forEach(doc -> getDocumentVersionValue(doc));

        List indexQueries = new ArrayList<>();
        docList.forEach(doc ->
                indexQueries.add(new IndexQueryBuilder().withId(getDocumentIdValue(doc)).withVersion(getDocumentVersionValue(doc)).withObject(doc).build()));

        return elasticsearchRestTemplate.bulkIndex(indexQueries, buildIndexCoordinates(indexName, nonTenantMode));
    }

    /**
     * 根据ID查询文档
     *
     * @param indexName     索引名称
     * @param docId         文档ID
     * @param clazz         映射类Class
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @param 
     * @return Elasticsearch 文档
     */
    public  T findById(String indexName, String docId, Class clazz, boolean nonTenantMode) {
        if (StringUtils.isNotEmpty(docId) && clazz != null) {
            return elasticsearchRestTemplate.get(docId, clazz, buildIndexCoordinates(indexName, nonTenantMode));
        }
        return null;
    }

    public  T findById(String docId, Class clazz) {
        return findById(docId, clazz, false);
    }

    @Override
    public  T findById(String docId, Class clazz, boolean nonTenantMode) {
        return findById(getEsIndexName(clazz), docId, clazz, nonTenantMode);
    }


    /**
     * 根据多个ID查询文档
     *
     * @param indexName     索引名称
     * @param docIdList      文档ID
     * @param clazz         映射类Class
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @param 
     * @return Elasticsearch 文档
     */
    @Override
    public  List findByIds(String indexName, Class clazz, List docIdList, boolean nonTenantMode) {
        if (CollectionUtils.isEmpty(docIdList) || clazz == null || indexName == null) {
            return null;
        }
        StringQuery query = StringQuery.builder("stringQuery").withIds(docIdList).build();
        List> result = elasticsearchRestTemplate.multiGet(query, clazz, buildIndexCoordinates(indexName, nonTenantMode));
        if(CollectionUtils.isEmpty(result)){
            return null;
        }

        List list = result.stream().map(o->o.getItem()).filter(item->item != null).collect(Collectors.toList());
        return list;
    }

    @Override
    public  List findByIds(Class clazz,List docIdList) {
        return findByIds( clazz, docIdList,false);
    }

    @Override
    public  List findByIds(Class clazz, List docIdList,boolean nonTenantMode) {
        return findByIds(getEsIndexName(clazz),  clazz,docIdList, nonTenantMode);
    }

    /**
     * 根据ID判断文档是否存在
     *
     * @param indexName 索引名称
     * @param docId     文档ID
     * @return 存在与否
     */
    private boolean existDocById(String indexName, String docId, boolean nonTenantMode) {
        if (existIndex(indexName, nonTenantMode) && StringUtils.isNotEmpty(docId)) {
            return elasticsearchRestTemplate.exists(docId, buildIndexCoordinates(indexName, nonTenantMode));
        }
        return Boolean.FALSE;
    }

    public boolean existDocById(Class clazz, String docId) {
        return existDocById(clazz, docId, false);
    }

    @Override
    public boolean existDocById(Class clazz, String docId, boolean nonTenantMode) {
        return existDocById(getEsIndexName(clazz), docId, nonTenantMode);
    }

    public  UpdateResponse.Result updateDoc(T elasticsearchModel) {
        return updateDoc(elasticsearchModel, false);
    }

    @Override
    public  UpdateResponse.Result updateDoc(T elasticsearchModel, boolean nonTenantMode) {
        String indexName = getEsIndexName(elasticsearchModel.getClass());
        return updateDoc(indexName, elasticsearchModel, nonTenantMode);
    }

    /**
     * 更新文档
     *
     * @param indexName          索引名称
     * @param elasticsearchModel elasticsearch文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id标注的文档ID值不能为空
     * @return UpdateResponse.Result
     * @throws JsonProcessingException JsonProcessingException
     */
    private  UpdateResponse.Result updateDoc(String indexName, T elasticsearchModel, boolean nonTenantMode) {
        return updateDoc(indexName, elasticsearchModel, this.objectMapper, nonTenantMode);
    }

    /**
     * 更新文档
     *
     * @param indexName          索引名称
     * @param elasticsearchModel elasticsearch文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id标注的文档ID值不能为空
     * @param objectMapper       objectMapper
     * @return UpdateResponse.Result
     */
    private  UpdateResponse.Result updateDoc(String indexName, T elasticsearchModel, ObjectMapper objectMapper) {
        return updateDoc(indexName, elasticsearchModel, objectMapper, false);
    }

    /**
     * 更新文档
     *
     * @param indexName          索引名称
     * @param elasticsearchModel elasticsearch文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id标注的文档ID值不能为空
     * @param objectMapper       objectMapper
     * @param nonTenantMode      是否是租户模式，false表示非租户模式，即通用索引
     * @return UpdateResponse.Result
     */
    private  UpdateResponse.Result updateDoc(String indexName, T elasticsearchModel, ObjectMapper objectMapper, boolean nonTenantMode) {
        Assert.notNull(indexName, "bulkUpdateDoc clazz is null");
        Assert.notNull(elasticsearchModel, "bulkUpdateDoc modelList is null");
        try {
            String id = getDocumentIdValue(elasticsearchModel);
            Assert.isTrue(existDocById(indexName, id, nonTenantMode), "elasticsearch document is not exist.");

            objectMapper = objectMapper == null ? this.objectMapper : objectMapper;
            String json = objectMapper.writeValueAsString(elasticsearchModel);
            UpdateQuery updateQuery = UpdateQuery.builder(id).withDocument(Document.parse(json)).build();

            return elasticsearchRestTemplate.update(updateQuery, buildIndexCoordinates(indexName, nonTenantMode)).getResult();
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    public  List bulkUpdateDoc(Class clazz, List modelList) {
        return bulkUpdateDoc(clazz, modelList, null);
    }

    public  List bulkUpdateDoc(Class clazz, List modelList, BulkOptions bulkOptions) {
        return bulkUpdateDoc(clazz, modelList, bulkOptions, objectMapper);
    }


    /**
     * 批量更新文档
     *
     * @param clazz        索引名称
     * @param modelList    elasticsearch文档; 文档需标注@Document注解、包含@Id注解字段, 且@Id标注的文档ID值不能为空
     * @param objectMapper objectMapper
     * @return UpdateResponse.Result
     */
    private  List bulkUpdateDoc(Class clazz, List modelList, BulkOptions bulkOptions,
                                                             ObjectMapper objectMapper) {
        Assert.notNull(clazz, "bulkUpdateDoc clazz is null");
        Assert.notNull(clazz, "bulkUpdateDoc modelList is null");

        try {
            List queries = new ArrayList(modelList.size());
            UpdateQuery updateQuery = null;
            String id = null;
            for (T model : modelList) {
                id = getDocumentIdValue(model);
                Assert.notNull(id, clazz.getName() + " instance document id is null");
                String json = objectMapper.writeValueAsString(model);
                updateQuery = UpdateQuery.builder(getDocumentIdValue(model)).withDocument(Document.parse(json)).build();
                queries.add(updateQuery);
            }
            bulkOptions = bulkOptions == null ? BulkOptions.defaultOptions() : bulkOptions;
            return elasticsearchRestTemplate.doBulkOperation(queries, bulkOptions, buildIndexCoordinates(clazz));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    private  String getDocumentIdValue(T elasticsearchModel) {
        return EsReflectUtils.getDocumentIdValue(elasticsearchModel);
    }

    private  Long getDocumentVersionValue(T elasticsearchModel) {
        return EsReflectUtils.getDocumentVersionValue(elasticsearchModel);
    }

    /**
     * 查询文档
     *
     * @param clazz         映射文档类 文档需标注@Document注解、包含@Id注解字段
     * @param queryBuilder  非结构化数据 QueryBuilder; queryBuilder与filterBuilder必须二者存在其一
     * @param filterBuilder 过滤查询
     * @param 
     * @return
     */
    public  SearchHits search(Class clazz, QueryBuilder queryBuilder, QueryBuilder filterBuilder,
                                    Pageable pageable) {
        MyEsSearchRequest request = new MyEsSearchRequest(queryBuilder, filterBuilder, pageable);
        return search(clazz, request);
    }

    @Override
    public  SearchHits search(Class clazz, QueryBuilder queryBuilder, QueryBuilder filterBuilder,
                                    Pageable pageable, boolean nonTenantMode) {
        MyEsSearchRequest request = new MyEsSearchRequest(queryBuilder, filterBuilder, pageable);
        return search(clazz, request, nonTenantMode);
    }

    public  SearchHits searchByFilter(Class clazz, QueryBuilder filterBuilder, Pageable pageable) {
        MyEsSearchRequest request = new MyEsSearchRequest(null, filterBuilder, pageable);
        return search(clazz, request);
    }

    @Override
    public  SearchHits searchByFilter(Class clazz, QueryBuilder filterBuilder, @javax.annotation.Nullable Pageable pageable, boolean nonTenantMode) {
        MyEsSearchRequest request = new MyEsSearchRequest(null, filterBuilder, pageable);
        return search(clazz, request, nonTenantMode);
    }

    public  SearchHits search(Class clazz, QueryBuilder queryBuilder, Pageable pageable) {
        MyEsSearchRequest request = new MyEsSearchRequest(queryBuilder, null, pageable);
        return search(clazz, request);
    }

    @Override
    public  SearchHits search(Class clazz, QueryBuilder queryBuilder, @javax.annotation.Nullable Pageable pageable, boolean nonTenantMode) {
        MyEsSearchRequest request = new MyEsSearchRequest(queryBuilder, null, pageable);
        return search(clazz, request, nonTenantMode);
    }

    public  SearchHits search(Class clazz, MyEsSearchRequest request) {
        return search(clazz, request, false);
    }

    @Override
    public  SearchHits search(Class clazz, MyEsSearchRequest request, boolean nonTenantMode) {
        return search(getEsIndexName(clazz), clazz, request.getQueryBuilder(), request.getFilterBuilder(),
                request.getAggregationBuilder(), request.getPageable(), request.getQueryFields(), nonTenantMode);
    }

    public  SearchHits search(Class clazz, NativeSearchQueryBuilder queryBuilder) {
        return search(clazz, queryBuilder, false);
    }

    @Override
    public  SearchHits search(Class clazz, NativeSearchQueryBuilder queryBuilder, boolean nonTenantMode) {
        return elasticsearchRestTemplate.search(queryBuilder.build(), clazz, buildIndexCoordinates(clazz, nonTenantMode));
    }

    /**
     * 查询文档
     *
     * 
     * 查询的文档必须包含映射@Document的@Id字段
     * 
     *
     * @param indexName                  索引名称
     * @param clazz                      映射文档类 文档需标注@Document注解、包含@Id注解字段
     * @param queryBuilder               非结构化数据 QueryBuilder; queryBuilder与filterBuilder必须二者存在其一
     * @param filterBuilder              结构化数据 QueryBuilder; filterBuilder与queryBuilder必须二者存在其一
     * @param abstractAggregationBuilder 聚合查询Builder
     * @param pageable                   分页/排序; 分页从0开始
     * @param fields                     包含字段
     * @param nonTenantMode              是否是租户模式，false表示非租户模式，即通用索引
     * @return
     */
    private  SearchHits search(String indexName, Class clazz, @Nullable QueryBuilder queryBuilder,
                                     @Nullable QueryBuilder filterBuilder,
                                     @Nullable AbstractAggregationBuilder abstractAggregationBuilder,
                                     @Nullable Pageable pageable, @Nullable String[] fields, boolean nonTenantMode) {
        if (StringUtils.isNotBlank(indexName)) {
            // 查询的文档必须包含映射@Document的@Id字段（
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().must(
                    QueryBuilders.existsQuery(EsReflectUtils.getDocumentIdFieldName(clazz)));
            if (queryBuilder != null) {
                boolQueryBuilder.must(queryBuilder);
            }
            NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder().withQuery(
                    boolQueryBuilder);
            if (filterBuilder != null) {
                nativeSearchQueryBuilder.withFilter(filterBuilder);
            }
            if (abstractAggregationBuilder != null) {
                nativeSearchQueryBuilder.withAggregations(abstractAggregationBuilder);
            }
            if (pageable != null) {
                nativeSearchQueryBuilder.withPageable(pageable);
            }
            if (fields != null && fields.length > 0) {
                nativeSearchQueryBuilder.withSourceFilter(new FetchSourceFilter(fields, null));
                //nativeSearchQueryBuilder.withFields(fields);
            }
//            nativeSearchQueryBuilder.withSorts(SortBuilders.fieldSort("id").order(SortOrder.ASC));
            return search(clazz, nativeSearchQueryBuilder, nonTenantMode);
        }
        return null;
    }

    @Override
    public String delIndexDoc(String id, Class clazz) {
        return delIndexDoc(id, clazz, false);
    }

    @Override
    public String delIndexDoc(String id, Class clazz, boolean nonTenantMode) {
        return elasticsearchRestTemplate.delete(id, buildIndexCoordinates(clazz, nonTenantMode));
    }

    @Override
    public  String delIndexDoc(T model) {
        return delIndexDoc(model, false);
    }

    @Override
    public  String delIndexDoc(T model, boolean nonTenantMode) {
        return delIndexDoc(EsReflectUtils.getDocumentIdValue(model), model.getClass(), nonTenantMode);
    }

    /**
     * 根据ID批量删除
     * 官方未提供根据id批量删除的，暂时就以循环删除的方式来操作，若有大批量操作存在性能问题考虑转为query delete方式
     *
     * @param clazz
     * @param ids
     * @return 返回每个ID删除后的返回结果
     */
    @Override
    public List bulkDelIndexDoc(Class clazz, List ids) {
        return bulkDelIndexDoc(clazz, ids, false);
    }

    /**
     * 根据ID批量删除
     * 官方未提供根据id批量删除的，暂时就以循环删除的方式来操作，若有大批量操作存在性能问题考虑转为query delete方式
     *
     * @param clazz
     * @param ids
     * @param nonTenantMode 是否是租户模式，true表示非租户模式，即通用索引
     * @return 返回每个ID删除后的返回结果
     */
    @Override
    public List bulkDelIndexDoc(Class clazz, List ids, boolean nonTenantMode) {
        if (clazz == null || CollectionUtils.isEmpty(ids)) {
            return null;
        }
        List delResutList = new ArrayList();
        for (String id : ids) {
            delResutList.add(elasticsearchRestTemplate.delete(id, buildIndexCoordinates(clazz, nonTenantMode)));
        }
        return delResutList;
    }

}

增删改查demo

package com.my.es.test;

import java.util.Date;
import java.util.List;


import com.my.elasticsearch.MyEsService;
import com.my.es.test.model.Shop;
import com.my.es.test.model.Student;
import com.my.elasticsearch.model.MyEsSearchRequest;
import com.fasterxml.jackson.core.JsonProcessingException;
import net.minidev.json.JSONObject;
import org.assertj.core.util.Lists;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;
import org.springframework.data.elasticsearch.core.query.UpdateResponse.Result;

/**
 * es demo
 *
 * @authro nantian
 * @date 2022-10-08 19:33
 */
@SpringBootTest
public class MyEsServiceTest {
    @Autowired
    private MyEsService myEsService;

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    @Test
    public void delIndex() {
        boolean result = myEsService.deleteIndexIfExist(Student.class);
        Assert.assertTrue(result);
    }

    @Test
    public void delIndexDoc() {
        String result = myEsService.delIndexDoc("3007", Student.class);
        System.out.println("delIndexDoc:" + Student.class.getName());
    }


    @Test
    public void updateMapping() {
        boolean result = myEsService.updateIndexMapping(Student.class);
        Assert.assertTrue(result);
    }


    @Test
    public void updateIndexMapping() {
        boolean result = myEsService.updateIndexMapping(Shop.class);
        Assert.assertTrue(result);
    }

    @Test
    public void createIndex() {
        boolean exist = myEsService.existIndex(Student.class);
        boolean result = false;
        if (!exist) {
            result = myEsService.createIndexIfNotExist(Student.class);
        } else {
            System.out.println("index exist:" + Student.class.getName());
        }
        Assert.assertTrue(result);
    }



    @Test
    public void createIndex3() {
        boolean result = myEsService.createIndexIfNotExist(Shop.class);
        System.out.println("index exist:" + Shop.class.getName());
        Assert.assertTrue(result);
    }

    @Test
    public void addIndexDoc() {
        Student student = new Student(1000, "张三", "测试索引添加", "哈哈", "三年二班刘", 10, new Date(), null);
        String documentId = myEsService.addIndexDoc(student);
        System.out.println("addIndexDoc result:" + documentId);
        Assert.assertNotNull(documentId);
    }

    @Test
    public void saveIndexDocWithVersion() {
        Student student = new Student(1009, "张三1001", "测试索引添加1", "哈哈", "三年二班刘11", 10, new Date(), null);
        Student existOne = myEsService.findById(student.getId() + "", Student.class);
        Long _version = existOne != null ? existOne.getVersion() + 1 : null;
        String documentId = myEsService.saveIndexDoc(student, _version);
        System.out.println("addIndexDoc result:" + documentId);
        Assert.assertNotNull(documentId);
    }

    @Test
    public void existIndex() {
        boolean result1 = myEsService.existIndex(Student.class);
        boolean result2 = myEsService.existIndex(Student.class, true);
        System.out.println(result1 + "------" + result2);
    }

    @Test
    public void saveIndexDocWithNonTenantModel() {
        Student student = new Student(1001, "张三1001", "测试索引添加1", "哈哈", "三年二班刘11", 10, new Date(), null);
        boolean nonTenantModel = true;
        if (nonTenantModel) {
            if (!myEsService.existIndex(Student.class, nonTenantModel)) {
                myEsService.createIndexIfNotExist(Student.class, nonTenantModel);
            }

        }
        Student existOne = myEsService.findById(student.getId() + "", Student.class, nonTenantModel);
        Long _version = existOne != null ? existOne.getVersion() + 1 : null;
        String documentId = myEsService.saveIndexDoc(student, _version, nonTenantModel);
        System.out.println("addIndexDoc result:" + documentId);
        Assert.assertNotNull(documentId);
    }


    @Test
    public void bulkAddIndexDoc2() {
        Student student1 = new Student(1000, "zs0", "测试索引添加0", "哈哈33ss", "三年二班刘先生中国", 10, new Date(), null);
        Student student2 = new Student(1001, "zs", "测试索引添加1", "哈哈dd", "五年二班周先生美国", 20, new Date(), null);
        Student student3 = new Student(1002, "zs", "测试索引添加2", "哈哈aa", "10年二班刘女士中国", 0, new Date(), null);
        Student student4 = new Student(1003, "zs1003", "测试索引添加3", "哈哈aadd", "八年二班张女士北京", 50, new Date(), null);
        Student student5 = new Student(1004, "zs1004", "测试索引添加4", "哈哈bbaa", "三年二班刘重生北京", 60, new Date(), null);
        Student student6 = new Student(1006, "zs1006", "测试索引添加4", "哈哈bbaa", "三年二班刘重生北京", 60, new Date(), null);
        Student student7 = new Student(1007, "zs1007", "测试索引添加4", "哈哈bbaa", "三年二班刘重生北京", 60, new Date(), null);
        List list = Lists.newArrayList(student1, student2, student3, student4, student5, student6, student7);
        List result = myEsService.bulkAddIndexDoc(Student.class, list);
        System.out.println("bulkAddIndexDoc result:" + JSONObject.toJSONString(result));
        Assert.assertNotNull(result.size() > 0);
    }

    @Test
    public void bulkSaveIndexDoc() {
        Student student1 = new Student(1020, "zs0", "测试索引添加0", "哈哈33ss", "三年二班刘先生中国", 11, new Date(), null);
        Student student2 = new Student(1021, "zs", "测试索引添加1", "哈哈dd", "五年二班周先生美国", 12, new Date(), null);
        Student student3 = new Student(1022, "zs", "测试索引添加2", "哈哈aa", "10年二班刘女士中国", 13, new Date(), null);
        List list = Lists.newArrayList(student1, student2, student3);

        for (Student student : list) {
            Student existOne = myEsService.findById(student.getId() + "", Student.class);
            Long _version = existOne != null ? existOne.getVersion() + 1 : 1;
            student.setVersion(_version);
        }

        List result = myEsService.bulkSaveIndexDoc(Student.class, list);
        System.out.println("bulkAddIndexDoc result:" + JSONObject.toJSONString(result));
        Assert.assertNotNull(result.size() > 0);
    }

    @Test
    public void getByIdStudent() {
        Student student = myEsService.findById("1000", Student.class);
        System.out.println(JSONObject.toJSONString(student));
    }

    @Test
    public void updateDoc() throws JsonProcessingException {
        Student student = new Student();
        student.setId(1000);
        student.setAge(30);
        student.setText("lisi");
        UpdateResponse.Result result = myEsService.updateDoc(student);
        System.out.println("update result:" + JSONObject.toJSONString(result));
        Student student2 = myEsService.findById("1000", Student.class);
        System.out.println(JSONObject.toJSONString(student2));
        Assert.assertTrue(Result.UPDATED == result);
    }

    @Test
    public void searchAll() {
        SearchHits hits = myEsService.search(Student.class, QueryBuilders.matchAllQuery(), null);
        System.out.println(JSONObject.toJSONString(hits));
    }

    @Test
    public void searchBySingleField() {
        QueryBuilder queryBuilder = QueryBuilders.matchQuery("name", "zs0");
        SearchHits hits = myEsService.search(Student.class, queryBuilder, null);
        System.out.println(JSONObject.toJSONString(hits));
    }

    @Test
    public void searchByFilter() {
        MyEsSearchRequest request = new MyEsSearchRequest();
        request.setQueryFields(new String[]{"name", "id", "_version"});

        //1
        QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery("zs", "name", "text");
        request.setQueryBuilder(queryBuilder);

        //2
        MatchQueryBuilder queryBuilder1 = QueryBuilders.matchQuery("name", "zs");
        RangeQueryBuilder queryBuilder2 = QueryBuilders.rangeQuery("age").gte("10").lte("60");
        MatchQueryBuilder fuzzyQueryBuilder = QueryBuilders.matchQuery("desc", "哈哈");

        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.should(queryBuilder1);
        boolQueryBuilder.should(queryBuilder2);
        boolQueryBuilder.should(fuzzyQueryBuilder);

        BoolQueryBuilder filterQueryBuilder = QueryBuilders.boolQuery();
        filterQueryBuilder.should(QueryBuilders.matchQuery("id", "1000"));
        request.setFilterBuilder(filterQueryBuilder);

        //3 分页及排序
        request.setQueryBuilder(boolQueryBuilder);
        Sort sort = Sort.by(Direction.DESC, "age");
        PageRequest pageRequest = PageRequest.of(0, 10, sort);
        request.setPageable(pageRequest);

        SearchHits hits = myEsService.search(Student.class, request);
        System.out.println(JSONObject.toJSONString(hits));
    }
}

八、ES管理工具

推荐使用官方的kibana，功能更全面

安装集群管理工具- Kibana

Kibanan安装比较简单，es集群搭建成功后，修改config/kibana.yml 加入以下配置，启动即可

#设置为中文
i18n.locale: "zh-CN"
#允许其它IP可以访问
server.host: "0.0.0.0"
elasticsearch.username: "kibana_system"
elasticsearch.password: "elastic123"
#es集群地址,填写真实的节点地址
elasticsearch.hosts: ["http://xxx.xx.xx.xx:9200","http://xxx.xx.xx.xx:9200","http://xxx.xx.xx.xx:9200"]

启动命令

./bin/kibana

es-header插件安装使用

官方文档: https://github.com/mobz/elasticsearch-head

es-header 插件是一个方便查看es集群、索引管理的一个工具，非官方提供，使用方式一般是安装chrome插件或下载安装header包进行本地安装（需要安装node），具体安装方式参考上面的文档, 以下是es-header图示：

说明

# 是否支持跨域,es-header插件使用
http.cors.enabled: true
# *表示支持所有域名跨域访问
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization,X-Requested-With,Content-Type,Content-Length

 http://localhost:9200/?auth_user=elastic&auth_password=elastic123

开启跨域访问，使用es-header需要在es的配置文件中添加以下配置开启跨域访问
添加口令访问，如果es集群开启了口令访问，es-header使用时需要在url后添加口令，示例如下：

九、ES集群安全策略

ES 7以下默认几乎没有任何安全策略，如果IP、端口被暴露，在可访问的情况下任何用户都可以对索引进行管理，以及数据的查询、删除等，基于此需要考虑设置一定的安全策略, 目前常用几种方式如下：

类别	优点	缺点	建议
nginx	对外屏蔽了ES集群的真实IP和端口，配置也较简单	只能做一些网络访问安全上面的防护，不能对索引及字段进行精确控制	选择X-pack 经验证在免费情况下X-Pack能满足基本诉求，对应用中使用影响也比较小
Search Guard	开源免费，基于RBAC权限模型设计，能够细粒度进行管控	配置复杂，需要安装证书及业务应用代码改造
X-Pack	官方提供，基于RBAC权限模型设计，能够细粒度进行管控，与client api及es集群兼容性较好	配置稍复杂，基础部分功能免费

X-pack安全策略开启及集群配置

第一步：在ES的根目录生成CA证书

bin/elasticsearch-certutil ca

步骤执行完会在elasticsearch根目录生成：elastic-stack-ca.p12

注意：

1、提示输入输出文件，直接回车默认即可

2、提示输入密码，务必输入，第二步要用到，如果都是空密码后面启动es时会出password incorrect错误

第二步：使用第一步生成的证书，产生p12密钥

bin/elasticsearch-certutil cert --ca elastic-stack-ca.p12

步骤执行完会在elasticsearch根目录生成： elastic-certificates.p12

注意：这一步共有三个交互

Enter password for CA (elastic-stack-ca.p12)

输入第一步中设置的的密码：

Please enter the desired output file [elastic-certificates.p12]:

不用输入文件，直接回车默认即可

Enter password for elastic-certificates.p12 :

不要输入密码，直接回车，否则还会出现es启动时报 password incorrect错误

第三步: 配置证书

1、将以上两个文件拷贝到config/certs目录，没有则新创建

2、配置elasticsearch.yml

xpack.security.enabled: true xpack.license.self_generated.type: basic xpack.security.transport.ssl.enabled: true xpack.security.transport.ssl.verification_mode: certificate xpack.security.transport.ssl.keystore.path: certs/elastic-certificates.p12 xpack.security.transport.ssl.truststore.path: certs/elastic-certificates.p12

注意：

第一步和 第二步整个集群只须执行一次，第一个节点配置完后把证书copy到其它节点共用即可
elasticsearch.yml 同样集群中每个es节点都需要配置

第四步：重启ES

重启ES看是否能正常启动,是否有ssl相关的错误信息，若无则一般说明配置没有问题

重启成功再访问ES时则会提示输入用户名密码，此时说明es安全已经启用，此时由于没有设置密码是无法登录的，接下来按第5步进行操作

注意：

先配置单个节点，重启ES看是否正常，如果正常其它节点再进行同样的操作

十、ES运维

数据备份与恢复

es官方提供了数据备份和恢复的方式，基本思路是用官方提供的API创建数据备份文件，然后再用恢复数据的API进行恢复，es默认情况下都是对整个集群的所有索引进行备份，也可进行定制只备份部分索引，恢复时也需要根据情况来恢复指定的索引数据，es均提供有相应的定制能力。

官方文档

https://www.elastic.co/guide/en/elasticsearch/reference/7.6/snapshots-register-repository.html

第一步：配置备份与恢复目录

es规范要求必须先在 elasticsearch.yml中配置备份恢复目录，后续才可使用该目录进行备份和恢复，当然每个es节点都要进行配置。

配置如下:

path.repo: ["/data/backups", "/data2/backups"]

目录可以写一到多个，一般写一个即可,配置加上后需要重启es集群

第二步：创建一个备份/快照

创建备份的三种方式

1、kibana上的dev_tools工具
- 该工具就是手动在kibana，填写备份与恢复API、参数等进行数据的备份与恢复，能够灵活的定制一些备份和恢复策略，也可以借助此工具熟悉es数据备份和恢复的各种操作命令，但不能自动进行备份
2、kibana提供的备份与恢复管理工具 [ 建议使用 ]
提供了快照查看、备份目录管理、创建备份快照的策略（如：多长时间创建一次快照）、快照恢复等功能，基本能够满足日常的使用，但存在问题是kibana这个产品上很多数据也是存在ES集群中，如果ES集群出现问题比如数据丢失Kibana也可能无法使用，此时我们就需要使用curl等方式发送http请求来恢复数据
- 工具路径，ip与port自行替换 http://127.0.0.1:5601/app/management/data/snapshot_restore/snapshots

3、使用curl发送 http请求 方式【 终极方式】

当kibanan不可用时可以采用此方式，算是个保留的救命手段，此方式在备份与恢复使用的API及请求参数与第1种方式一致，只是使用了不同的工具来发送请求而已。

这种方式在发送请求时需要填写集群地址及集群的访问口令，例如查看一个快照状态：
```
curl -u elastic:elastic123 -X POST 'http://ip:9200/_snapshot/jingkai_backup/snapshot/_status'
```

快照创建操作命令

以下api适用于第1、3两种方式

（1）创建一个备份仓库

创建备份前需要先创建一个仓库，所有的备份都需要放在仓库中，一个es集群可以有多个备份仓库

PUT /_snapshot/backup1 { "type": "fs", "settings": { "location": "/data/backups", "compress": true, "max_snapshot_bytes_per_sec": "50mb", "max_restore_bytes_per_sec": "50mb" } }

其它命令

（1）查看所有仓库： GET /_snapshot

属性说明
- _snapshot 命令是指创建一个备份快照，后面的路径【backup1】可以认为是仓库的名字
- type=fs：代表是文件系统来存储备份，其它方式暂没有找到
- location：当前备份存放的目录
- compress: 是否开启压缩
- max_snapshot_bytes_per_sec：备份时最大写入数据速度，可以根据实际硬件配置进行填写
- max_restore_bytes_per_sec：恢复时最大读取速度

（2）创建一个备份/快照

json属性参数也可不填

PUT /_snapshot/backup1/snapshot_20221013?wait_for_completion=true { "indices": "index_1,index_2", "ignore_unavailable": true, "include_global_state": false }

wait_for_completion=true 设置为true时，操作界面会等待快照备份的结果，当索引比较大备份时间很长也有可能看不到结果，此时可以设置为false然后用以下命令查看备份进度
```
GET /_snapshot/backup1/snapshot_20221013/_status
```
"indices": "index_1,index_2" ：可以使用该参数只对部分索引进行备份
ignore_unavailable=true：忽略不可用的索引
include_global_state =false 可以防止将群集全局状态存储为快照的一部分。默认情况下，如果参与快照的一个或多个索引没有所有可用的主分片，则整个快照将失败。可以通过设置为partial来更改此行为true。

（3）查看某个快照

GET /_snapshot/backup1/snapshot_20221013
GET /_snapshot/backup1/snapshot_20221013/_status

（4）终止创建/删除快照

当备份时执行则可以终止备份，当备份结束后执行可以删除快照

DELETE /_snapshot/backup1/snapshot_20221013

第三步：数据恢复

es集群上有比较多的索引数据，除了业务索引还有es和Kibana等一些配套工具生成的系统内置索引，备份时如果没有指定只对部分索引进行备份，那默认是全部备份，当整个集群出现问题也可以使用此进行恢复。但在实际场景中可能只会对某部分出现问题的索引进行恢复，或者是想重命名及重建索引，这时候就需要在恢复时设置相应的参数。

注意：集群中正在提供服务的索引【状态为open】,是无法直接进行恢复的，强行恢复会提示『because an open index with same name already exists in the cluster』，此时需要先把索引关闭，但关闭索引就会影响线上业务功能，所以恢复索引时需要慎重操作。如果集群已经不可用了，可以直接使用。如果不能停机恢复可能需要借助索引别名及索引重建方式来恢复索引。

使用Kibana工具恢复

具体步骤就不进行赘述了,按界面上提供的功能进行操作即可

使用dev_tools、curl方式进行恢复

(1) 执行恢复

POST /_snapshot/backup1/snapshot_20221013/_restore { "indices": "index_1,index_2", "ignore_unavailable": true, "include_global_state": true, "rename_pattern": "index_(.+)", "rename_replacement": "restored_index_$1", "include_aliases": false }

_restore ：为恢复快照命令
indices：要恢复的索引，支持使用索引别名, 支持通配符表达式, 多个索引名称用逗号拼接，如果不指定 indices , 则表示恢复所有索引.
ignore_unavailable ：为true则恢复时忽略不可用的索引
include_global_state：设置为false，则不把快照中的状态恢复到当前集群中
rename_pattern：可省参数，重命名索引的匹配规则，使用此参数可以让A索引恢复到B索引上，有点类似重建或重命名的意思，无此参数则直接还原到当前索引【当前索引必须是close状态】，此参数与rename_replacement须一起使用，一般使用正则匹配
rename_replacement：可省参数，重命名恢复的索引，须与rename_pattern结合使用，【$1】为rename_pattern中匹配到的数据，restored_index_则为恢复的索引添加了一个新的前缀名
include_aliases: false 防止别名与关联索引一起还原

(2) 终止恢复-慎用

注意：es并未提供单独的停止恢复命令，而是通过删除快照操作来达到终止恢复，所以执行此命令有可能导致快照数据也会被删除

DELETE /_snapshot/backup1/snapshot_20221013

索引重建

索引重建不是对当前索引进行重建，而是把一个索引重建到一个新的索引上，新的索引mapping,setting可以单独设置，在某些场景比如一开始索引设置的是5个分片，当集群节点增加后我们可以创建一个新的索引把分片设置更大一点，然后使用以下命令把数据重建到新索引上，然后应用访问新索引

POST _reindex { "source": { "index": "app1_pay_order_index" }, "dest": { "index": "app1_pay_order_index_new" } }

注：索引重建结合索引别名功能，可以实现不停机索引切换

索引设置别名

索引设置别名后，我们可以使用别名对索引进行操作，与原名一样，别名在数据恢复或者重建场景非常有用，程序中建议使用别名进行访问索引

添加&删除别名

remove 删除索引别名add 给索引添加别名

POST /_aliases { "actions": [ #删除别名 { "remove": { "index": "app1_pay_order", "alias": "app1_pay_order2" } }, #添加别名 { "add": { "index": "app1_pay_order_new", "alias": "app1_pay_order2" }} ] }

查询所有索引别名

GET _alias

查询指定索引别名

GET app1_pay_order/_alias

十一、ES常用操作命令

es启动
- 命令：./bin/elasticsearch
- 访问地址：http://localhost:9200/ 默认9200端口
Kibana 启动
- 命令：./bin/kibana
- 访问地址： http://localhost:5600/ 默认5600端口
查看集群状态

  检查集群运行情况： GET -> localhost:9200/_cat/health?v

  查看集群节点列表： GET -> localhost:9200/_cat/nodes

  查看所有索引： GET -> localhost:9200/_cat/indices?v

索引操作API

es集群所的操作都可以http方式进行操作，当然也可以使用kibana上的开发工具操作，kibana操作更简单些。

//1.查询查看分片状态-Authorization方式（postman通过账密获取token）
curl -XGET ‘http://127.0.0.1:9200/_cluster/allocation/explain?pretty’ --header ‘Authorization’: Basic ZWxhc3RpYzphcDIwcE9QUzIw’

//2.查询查看分片状态-账密方式
curl -XGET -u elastic "http://127.0.0.1:9200/_cluster/allocation/explain?pretty" -H ‘Content-Type:application/json’

//3.查询集群状态命令
curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cluster/health?pretty"

//4.查询Es全局状态
curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cluster/stats?pretty"

//5.查询集群设置
curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cluster/settings?pretty"

//6.查询集群文档总数
curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cat/count?v"

//7.查看当前集群索引分片信息
curl -XGET -u elastic:elastic123 "http://127.0.0.1:9200/_cat/shards?v"

//8.查看集群实例存储详细信息
curl -XGET -u elastic "http://127.0.0.1:9200/_cat/allocation?v"

//9.查看当前集群的所有实例
curl -XGET -u elastic "http://127.0.0.1:9200/_cat/nodes?v"

//10.查看当前集群等待任务
curl -XGET -u elastic "http://127.0.0.1:9200/_cat/pending_tasks?v"

//11.查看集群查询线程池任务
curl -XGET -u elastic "http://127.0.0.1:9200/_cat/thread_pool/search?v"

//12.查看集群写入线程池任务
curl -XGET -u elastic "http://127.0.0.1:9200/_cat/thread_pool/bulk?v"

//13.清理ES所有缓存
curl -XPOST "http://127.0.0.1:9200/_cache/clear"

//14.查询索引信息
curl -XGET -u : ‘https://127.0.0.1:9200/licence_info_test?pretty’

//15.关闭索引
curl -XGET -u : ‘https://127.0.0.1:9200/my_index/_close?pretty’

//16.打开索引
curl -XGET -u : ‘https://127.0.0.1:9200/my_index/_open?pretty’

kibana工具

十二、ES 相关资料

gitHub地址

https://github.com/elastic/elasticsearch/

官方文档

https://www.elastic.co/cn/downloads/past-releases/#kibana

wiki
- Elasticsearch 集群协调迎来新时代
  - https://www.elastic.co/cn/blog/a-new-era-for-cluster-coordination-in-elasticsearch
- Elasticsearch 集群内应该设置多少个分片？
  - https://www.elastic.co/cn/blog/how-many-shards-should-i-have-in-my-elasticsearch-cluster
- Es spring-boot-starter wiki
  - https://docs.spring.io/spring-data/elasticsearch/docs/4.3.7/reference/html/#reference

你可能感兴趣的:(spring,JAVA杂七杂八,spring,elasticsearch,es,maven,spring,boot)

C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
linux sdl windows.h,Windows下的SDL安装奔跑吧linux内核 linux sdl windows.h
首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
Git常用命令－修改远程仓库地址猿大师 Linux Java git java
查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http 网络协议网络 python
RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
docker igotyback eureka 云原生
Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
mac电脑命令行获取电量小米人er 我的博客 macos 命令行
在macOS上，有几个命令行工具可以用来获取电量信息，最常用的是pmset命令。你可以通过以下方式来查看电池状态和电量信息：查看电池状态：pmset-gbatt这个命令会返回类似下面的输出：Nowdrawingfrom'BatteryPower'-InternalBattery-0(id=1234567)95%;discharging;4:02remainingpresent:true输出中包括电
Maven Array_06 eclipse jdk maven
Maven Maven是基于项目对象模型(POM)，信息来管理项目的构建，报告和文档的软件项目管理工具。 Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
ibatis的queyrForList和queryForMap区别 bijian1013 java ibatis
一.说明 iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之： 1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
LeetCode[位运算] - #191 计算汉明权重 Cwind java 位运算 LeetCode Algorithm 题解
原题链接：#191 Number of 1 Bits 要求：写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。难度：简单分析：将十进制参数转换为二进制，然后计算其中1的个数即可。 “
浅谈java类与对象 15700786134 java
java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
linux下双网卡同一个IP 被触发 linux
转自： http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少：一、关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
安卓按主页键隐藏程序之后无法再次打开肆无忌惮_ 安卓
遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity 本来代码： // 销毁这个Activity fin
通过cookie保存并读取用户登录信息实例知了ing JavaScript html
通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。下面通过cookie保存并读取用户登录信息的例子加深一下理解。（1）创建index.jsp文件。在改
JAVA 对象池矮蛋蛋 java ObjectPool
原文地址： http://www.blogjava.net/baoyaer/articles/218460.html Jakarta对象池 ☆为什么使用对象池恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
ArrayList根据条件+for循环批量删除的方法 alleni123 java
场景如下： ArrayList<Obj> list Obj-> createTime, sid. 现在要根据obj的createTime来进行定期清理。（释放内存） ------------------------- 首先想到的方法就是 for(Obj o:list){ if(o.createTime-currentT>xxx){
阿里巴巴“耕地宝”大战各种宝百合不是茶平台战略
“耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿，主要是用来进行农业方面，将农民手中的散地集中起来不仅加大农民集体在土地上面的话语权，还增加了土地的流通与利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权将更少，国家应出台相应的法律法规保护
Spring注入有继承关系的类（1） bijian1013 java spring
一个类一个类的注入 1.AClass类 package com.bijian.spring.test2; public class AClass { String a; String b; public String getA() { return a; } public void setA(Strin
30岁转型期你能否成为成功人士 bijian1013 成功
很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
[Velocity三]基于Servlet+Velocity的web应用 bit1129 velocity
什么是VelocityViewServlet 使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用 Servlet + Velocity的一般步骤 1.自定义Servlet，实现VelocityViewServl
【Kafka十二】关于Kafka是一个Commit Log Service bit1129 service
Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？ A message is considered "committed" when all in sync replicas for that partition have applied i
NGINX + LUA实现复杂的控制 ronin47 lua nginx 控制
安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
java-14.输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字 bylijinnan java
public class TwoElementEqualSum { /** * 第 14 题：题目：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于
Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder bylijinnan java netty
今天看Netty如何实现一个Http Server org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： pipeline.addLast("decoder", new HttpRequestDecoder()); pipeline.addLast(&quo
java敏感词过虑-基于多叉树原理 cngolon 违禁词过虑替换违禁词敏感词过虑多叉树
基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。 2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 utf-8的words.dict文本文件，
多线程知识 cuishikuan 多线程
T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 public class T1 implements Runnable{ @Override
spring整合activemq dalan_123 java spring jms
整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分： a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接 b、真正产生到JMS服务器链接的ConnectionFactory还得
MySQL时间字段究竟使用INT还是DateTime？ dcj3sjt126com mysql
环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 第一步、创建一个表date_test（非定长、int时间） CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
Parcel: unable to marshal value dcj3sjt126com marshal
在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）： Intent intent = new Intent(this, Next
linux进程的查看上（ps） eksliang linux ps linux ps -l linux ps aux
ps:将某个时间点的进程运行情况选取下来转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 http://eksliang.iteye.com ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
为什么第三方应用能早于System的app启动 gqdy365 System
Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
App Framework发送JSONP请求(3) hw1287789687 jsonp 跨域请求发送jsonp ajax请求越狱请求
App Framework 中如何发送JSONP请求呢? 使用jsonp,详情请参考:http://json-p.org/ 如何发送Ajax请求呢? (1)登录 /*** * 会员登录 * @param username * @param password */ var user_login=function(username,password){ // aler
发福利，整理了一份关于“资源汇总”的汇总 justjavac 资源
觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN 通用 free-programming-books-zh_CN 免费的计算机编程类中文书籍精彩博客集合 hacke2/hacke2.github.io#2 ResumeSample 程序员简历
用 Java 技术创建 RESTful Web 服务 macroli java 编程 Web REST
转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/ JAX-RS (JSR-311) 【 Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项超声波 oracle linux
前言：这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。安装过程中可能遇到的问题（注
HttpClient 4.3 设置keeplive 和 timeout 的方法 supben httpclient
ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() { @Override public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive
Spring 4.2新特性-@Import注解的升级 wiselyman spring 4
3.1 @Import @Import注解在4.2之前只支持导入配置类在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 3.2 示例演示java类 package com.wisely.spring4_2.imp; public class DemoService { public void doSomethin

一篇掌握Elasticsearch7.10集群搭建到实战

一、背景

二、内容概要

三、基础概念

四、ES版本选择

elasticsearch版本选择

ES客户端SDK版本选择

五、Elasticsearch多租户

多租户下的架构

租户的识别和路由

六、ES 集群搭建

集群部署架构

单集群示例

多集群示例

集群访问规范

ES集群搭建配置

1、先搭建单个节点

2、启动ES

3、设置安全账号信息（ES要启动状态）

4、添加配置集群配置信息

5 、jvm.options

6、配置集群其它节点

7、关闭索引自动创建

8、修改es集群索引默认分片数

集群索引分片策略

安装中文分词插件 IK

七、ES SDK及增删改查

1、应用添加依赖

2、application.properties 添加es链接配置

3、Demo，（更多示例可以看单元测试部分）

八、ES管理工具

安装集群管理工具- Kibana

es-header插件安装使用

九、ES集群安全策略

X-pack安全策略开启及集群配置

第一步：在ES的根目录生成CA证书

第二步： 使用第一步生成的证书，产生p12密钥

第三步: 配置证书

第四步：重启ES

十、ES运维

数据备份与恢复

第一步：配置备份与恢复目录

第二步：创建一个备份/快照

创建备份的三种方式

快照创建操作命令

（1） 创建一个备份仓库

（2）创建一个备份/快照

（4）终止创建/删除快照

第三步：数据恢复

使用Kibana工具恢复

使用dev_tools、curl方式进行恢复

(1) 执行恢复

(2) 终止恢复-慎用

索引重建

索引设置别名

添加&删除别名

查询指定索引别名

十一、ES常用操作命令

十二、ES 相关资料

官方文档

你可能感兴趣的:(spring,JAVA杂七杂八,spring,elasticsearch,es,maven,spring,boot)

第二步：使用第一步生成的证书，产生p12密钥

（1）创建一个备份仓库