Lucene 和 Kibana、ElasticSeach、Spring Data ElasticSearch

客户端请求 ----> 连接器

连接器 ----> 缓存区
连接器 ----> 分析器

分析器 ----> 缓存区
分析器 ----> 优化器

优化器 ----> 执行器

Server 层：
- 连接器
- 缓存区
- 分析器
- 优化器
- 执行器

Server 层 ----> 存储引擎（引擎，引擎，引擎）

1. 稳定、索引性能高。
+ 每小时能够索引 150 GB 以上的数据
+ 对内存的要求小，只需要 1 MB 的堆内存
+ 增量索引和批量索引一样快
+ 索引的大小约为索引文本大小的 20% ~ 30%

2. 高效、准确、高性能的搜索算法。
+ 良好的搜索排序
+ 强大的查询方式支持：短语查询、通配符查询、临近查询、范围查询等
+ 支持字段搜索（如标题、作者、内容）
+ 可根据任意字段排序
+ 支持多个索引查询结果合并
+ 支持更新操作和查询操作同时进行
+ 支持高亮、join、分组结果功能
+ 速度快
+ 可扩展排序模块，内置包含向量空间模型、BM25 模型可选
+ 可配置存储引擎

3. 跨平台。
+ 纯 java 编写
+ 作为 Apache 开源许可下的开源项目，你可以在商业或开源项目中使用
+ Lucene 有多种语言实现版（如 C，C++、Python 等），不仅仅是 JAVA

Application:
+ 从文件系统、数据库、Web、手动输入获取数据，然后生成索引。
+ 获取用户的 Query，然后查询索引，返回查询结果给用户。

用户 
--职位搜索--> 应用服务器
--SQL--> 结构化数据库

Lucene：
+ 生成索引需要与索引库交互。
+ 查询索引需要与索引库交互。

用户 
--职位搜索--> 应用服务器
--特定API--> Lucene索引库

数据源（网络、数据库、文档）
----> Lucene索引库

查询索引：
1. 用户查询接口
2. 创建查询
3. 执行查询
4. 渲染结果

用户查询索引 
-----> 索引库

原始文档 
----> 创建索引
--创建索引--> 索引库
--返回结果--> 用户查询索引

创建索引：
1. 获取文档
2. 构建文档对象
3. 分析文档（分词）
4. 创建索引

/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`es` /*!40100 DEFAULT CHARACTER SET latin1 */;

USE `es`;

/*Table structure for table `job_info` */

DROP TABLE IF EXISTS `job_info`;

CREATE TABLE `job_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键 id',
  `company_name` varchar(100) DEFAULT NULL COMMENT '公司名称',
  `company_addr` varchar(200) DEFAULT NULL COMMENT '公司联系方式',
  `company_info` mediumtext COMMENT '公司信息',
  `job_name` varchar(100) DEFAULT NULL COMMENT '职位名称',
  `job_addr` varchar(50) DEFAULT NULL COMMENT '工作地点',
  `job_info` mediumtext COMMENT '职位信息',
  `salary_min` int(10) DEFAULT NULL COMMENT '薪资范围，最小',
  `salary_max` int(10) DEFAULT NULL COMMENT '薪资范围，最大',
  `url` varchar(150) DEFAULT NULL COMMENT '招聘信息详情页',
  `time` varchar(10) DEFAULT NULL COMMENT '职位最近发布时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7656 DEFAULT CHARSET=utf8 COMMENT='招聘信息';

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.renda</groupId>
    <artifactId>lucene-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>lucene-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <!-- web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- lombok 工具 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
            <scope>provided</scope>
        </dependency>
        <!-- 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>
        <!-- pojo 持久化使用 -->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>
        <!-- mysql 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 引入 Lucene 核心包及分词器包 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-core</artifactId>
            <version>4.10.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-analyzers-common</artifactId>
            <version>4.10.3</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- IK 中文分词器 -->
        <dependency>
            <groupId>com.janeluo</groupId>
            <artifactId>ikanalyzer</artifactId>
            <version>2012_u6</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <!-- 打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

package com.renda;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.renda.mapper")
public class LuceneDemoApplication {

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

}

server:
  port: 9000
Spring:
  application:
    name: lagou-lucene
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/es?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    username: root
    password: password

# 开启驼峰命名匹配映射
mybatis:
  configuration:
    map-underscore-to-camel-case: true

package com.renda.pojo;

import lombok.Data;
import lombok.ToString;

import javax.persistence.Id;
import javax.persistence.Table;

@Data
@ToString
@Table(name = "job_info")
public class JobInfo {

    @Id
    private long id;
    private String companyName;
    private String companyAddr;
    private String companyInfo;
    private String jobName;
    private String jobAddr;
    private String jobInfo;
    private long salaryMin;
    private long salaryMax;
    private String url;
    private String time;

}

public interface JobInfoMapper extends BaseMapper<JobInfo> {
}

public interface JobInfoService {

    /**
     * 通过id查询
     */
    public JobInfo selectById(long id);

    /**
     * 查询所有
     */
    public List<JobInfo> selectAll();

}

@Service
public class JobInfoServiceImpl implements JobInfoService {

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    private JobInfoMapper jobInfoMapper;

    @Override
    public JobInfo selectById(long id) {
        return jobInfoMapper.selectById(id);
    }

    @Override
    public List<JobInfo> selectAll() {
        return jobInfoMapper.selectList(new QueryWrapper<JobInfo>());
    }

}

@RestController
@RequestMapping("/jobInfo")
public class JobInfoController {

    @Autowired
    private JobInfoService jobInfoService;

    @RequestMapping("/query/{id}")
    public JobInfo selectById(@PathVariable Long id){
        return jobInfoService.selectById(id);
    }

    @RequestMapping("/query")
    public List<JobInfo> select(){
        return jobInfoService.selectAll();
    }

}

@RunWith(SpringRunner.class)
@SpringBootTest
public class LuceneDemoApplicationTests {
    ...
}

+ src/main/java
  + com.renda.controller
    + JobInfoController
  + com.renda.mapper
    + JobInfoMapper
  + com.renda.pojo
    + JobInfo
  + com.renda.service
    + impl.JobInfoServiceImpl
    + JobInfoService
  + com.renda
    + LuceneDemoApplication
+ src/main/resources
  + static
  + templates
  + application.yml
+ src/test/java
  + com.renda
    + LuceneDemoApplicationTests

@RunWith(SpringRunner.class)
@SpringBootTest
public class LuceneDemoApplicationTests {

    @Autowired
    private JobInfoService jobInfoService;

    /**
     * 创建索引
     */
    @Test
    public void createIndex() throws Exception {
        // 1.指定索引文件的存储位置，索引具体的表现形式就是一组有规则的文件
        Directory directory = FSDirectory.open(new File("E:/class/index"));
        // 2.配置版本及其分词器
        Analyzer analyzer = new IKAnalyzer();
        IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, analyzer);
        // 3.创建 IndexWriter 对象，作用就是创建索引
        IndexWriter indexWriter = new IndexWriter(directory, config);
        // 先删除已经存在的索引库
        indexWriter.deleteAll();
        // 4.获得索引源 / 原始数据
        List<JobInfo> jobInfoList = jobInfoService.selectAll();
        // 5. 遍历 jobInfoList，每次遍历创建一个 Document 对象
        for (JobInfo jobInfo : jobInfoList) {
            // 创建 Document 对象
            Document document = new Document();
            // 创建 Field 对象，添加到 document 中
            document.add(new LongField("id", jobInfo.getId(), Field.Store.YES));
            // 切分词、索引、存储
            document.add(new TextField("companyName", jobInfo.getCompanyName(), Field.Store.YES));
            document.add(new TextField("companyAddr", jobInfo.getCompanyAddr(), Field.Store.YES));
            document.add(new TextField("companyInfo", jobInfo.getCompanyInfo(), Field.Store.YES));
            document.add(new TextField("jobName", jobInfo.getJobName(), Field.Store.YES));
            document.add(new TextField("jobAddr", jobInfo.getJobAddr(), Field.Store.YES));
            document.add(new TextField("jobInfo", jobInfo.getJobInfo(), Field.Store.YES));
            document.add(new LongField("salaryMin", jobInfo.getSalaryMin(), Field.Store.YES));
            document.add(new LongField("salaryMax", jobInfo.getSalaryMax(), Field.Store.YES));
            document.add(new StringField("url", jobInfo.getUrl(), Field.Store.YES));
            // 将文档追加到索引库中
            indexWriter.addDocument(document);
        }
        // 关闭资源
        indexWriter.close();
        System.out.println("Index was created successfully!");
    }

}

D:\class\index

_0.cfe
_0.cfs
_0.si
_1.cfe
_1.cfs
_1.si
segments.gen
segments_1
write.lock

是: 将 Field 的值进行分词处理，分词的目的是为了索引。如: 商品名称、商品描述。这些内容用户会通过输入关键词进行查询，由于内容多样，需要进行分词处理建立索引。

否: 不做分词处理，如: 订单编号、身份证号, 是一个整体，分词以后就失去了意义，故不需要分词。

是: 将 Field 内容进行分词处理后得到的词 (或整体 Field 内容) 建立索引，存储到索引域。索引的目的是为了搜索。如: 商品名称, 商品描述需要分词建立索引。订单编号、身份证号作为整体建立索引。只要可能作为用户查询条件的词, 都需要索引。

否: 不索引。如: 商品图片路径，不会作为查询条件，不需要建立索引。

是: 将 Field 值保存到 Document 中。如: 商品名称, 商品价格。凡是将来在搜索结果页面展现给用户的内容，都需要存储。

否: 不存储。如: 商品描述。内容多格式大，不需要直接在搜索结果页面展现，不做存储。需要的时候可以从关系数据库取。

@RunWith(SpringRunner.class)
@SpringBootTest
public class LuceneDemoApplicationTests {

    @Autowired
    private JobInfoService jobInfoService;

    ...

    @Test
    public void query() throws Exception {
        // 1.指定索引文件的存储位置，索引具体的表现形式就是一组有规则的文件
        Directory directory = FSDirectory.open(new File("E:/class/index"));
        // 2.IndexReader 对象
        IndexReader indexReader = DirectoryReader.open(directory);
        // 3.创建查询对象，IndexSearcher
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        // 使用 term, 查询公司名称中包含"北京"的所有的文档对象
        Query query = new TermQuery(new Term("companyName", "北京"));
        TopDocs topDocs = indexSearcher.search(query, );
        // 获得符合查询条件的文档数
        int totalHits = topDocs.totalHits;
        System.out.println("符合条件的文档数：" + totalHits);
        // 获得命中的文档  ScoreDoc封装了文档id信息
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {
            // 文档 id
            int docId = scoreDoc.doc;
            // 通过文档 id 获得文档对象
            Document doc = indexSearcher.doc(docId);
            System.out.println("id:" + doc.get("id"));
            System.out.println("companyName:" + doc.get("companyName"));
            System.out.println("companyAddr:" + doc.get("companyAddr"));
            System.out.println("companyInfo:" + doc.get("companyInfo"));
            System.out.println("jobName:" + doc.get("jobName"));
            System.out.println("jobInfo:" + doc.get("jobInfo"));
            System.out.println("*******************************************");
        }
        // 资源释放
        indexReader.close();
    }

}

<!-- IK 中文分词器 -->
<dependency>
    <groupId>com.janeluo</groupId>
    <artifactId>ikanalyzer</artifactId>
    <version>2012_u6</version>
</dependency>

IKAnalyzer.cfg.xml
stopword.dic

Analyzer analyzer = new IKAnalyzer();

MySQL ---Logstash数据同步---> ElasticSearch索引库

MySQL ---- MySQL可视化软件

ElasticSearch索引库 ---- Kibana可视化软件

\bin            命令，启动，关闭
\config         配置文件
\lib            ES 的 jar 包依赖
\logs           日志
\modules        ES 工作所依赖的一些组件，启动时加载
\plugins        放置一些第三方插件，如 IK 分词器
LICENSE.txt
NOTICE.txt
README.textile

# ----------------------------------- Paths ------------------------------------
#
# Path to directory where to store the data (separate multiple locations by comma):
#
path.data: e:\class\es\data
#
# Path to log files:
#
path.logs: e:\class\es\logs
#

# Xms represents the initial size of total heap space
# Xmx represents the maximum size of total heap space

-Xms256m
-Xmx256m

[2020-11-08T21:52:33,482][INFO ][o.e.n.Node               ] [G9aQRl_] starting ...
[2020-11-08T21:52:34,307][INFO ][o.e.t.TransportService   ] [G9aQRl_] publish_address {127.0.0.1:9300}, bound_addresses {127.0.0.1:9300}, {[::1]:9300}
[2020-11-08T21:52:37,363][INFO ][o.e.c.s.MasterService    ] [G9aQRl_] zen-disco-elected-as-master ([0] nodes joined), reason: new_master {G9aQRl_}{G9aQRl_qR2KeysskhZY0xQ}{87fblLs1Rci_HVjZVzVlOQ}{127.0.0.1}{127.0.0.1:9300}
[2020-11-08T21:52:37,363][INFO ][o.e.c.s.ClusterApplierService] [G9aQRl_] new_master {G9aQRl_}{G9aQRl_qR2KeysskhZY0xQ}{87fblLs1Rci_HVjZVzVlOQ}{127.0.0.1}{127.0.0.1:9300}, reason: apply cluster state (from master [master {G9aQRl_}{G9aQRl_qR2KeysskhZY0xQ}{87fblLs1Rci_HVjZVzVlOQ}{127.0.0.1}{127.0.0.1:9300} committed version [1] source [zen-disco-elected-as-master ([0] nodes joined)]])
[2020-11-08T21:52:37,426][INFO ][o.e.g.GatewayService     ] [G9aQRl_] recovered [0] indices into cluster_state
[2020-11-08T21:52:37,762][INFO ][o.e.h.n.Netty4HttpServerTransport] [G9aQRl_] publish_address {127.0.0.1:9200}, bound_addresses {127.0.0.1:9200}, {[::1]:9200}
[2020-11-08T21:52:37,762][INFO ][o.e.n.Node               ] [G9aQRl_] started

{
  "name" : "G9aQRl_",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "ezpbwfUtTqubgqUGPvJWAg",
  "version" : {
    "number" : "6.2.4",
    "build_hash" : "ccec39f",
    "build_date" : "2018-04-12T20:37:28.497551Z",
    "build_snapshot" : false,
    "lucene_version" : "7.2.1",
    "minimum_wire_compatibility_version" : "5.6.0",
    "minimum_index_compatibility_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

elasticsearch.url: "http://localhost:9200"

  log   [14:05:55.974] [info][listening] Server running at http://localhost:5601
  log   [14:05:56.031] [info][status][plugin:elasticsearch@6.2.4] Status changed from yellow to green - Ready

GET _search
{
  "query": {
    "match_all": {}
  }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": []
  }
}

GET /_analyze
{
  "analyzer": "ik_max_word",
  "text": "我是中国人"
}

{
  "tokens": [
    {
      "token": "我",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_CHAR",
      "position": 
    },
    {
      "token": "是",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_CHAR",
      "position": 
    },
    {
      "token": "中国人",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_WORD",
      "position": 
    },
    {
      "token": "中国",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_WORD",
      "position": 
    },
    {
      "token": "国人",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_WORD",
      "position": 
    }
  ]
}

GET /_analyze
{
  "analyzer": "ik_smart",
  "text": "我是中国人"
}

{
  "tokens": [
    {
      "token": "我",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_CHAR",
      "position": 
    },
    {
      "token": "是",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_CHAR",
      "position": 
    },
    {
      "token": "中国人",
      "start_offset": ,
      "end_offset": ,
      "type": "CN_WORD",
      "position": 
    }
  ]
}

索引库 indices ----- Database 数据库
类型 type ---- Table 数据表
文档 Document ----- Row 行
域字段 Field ----- Columns 列 

映射配置 mappings ----- 每个列的约束（类型、长度） 

{
    "settings": {
        "属性名": "属性值"
    }
}

PUT /renda

{
  "acknowledged": true,
  "shards_acknowledged": true,
  "index": "renda"
}

GET /renda

{
  "renda": {
    "aliases": {},
    "mappings": {},
    "settings": {
      "index": {
        "creation_date": "1604847321532",
        "number_of_shards": "5",
        "number_of_replicas": "1",
        "uuid": "ZlK7XTn6S8OIOAdhPCvnxA",
        "version": {
          "created": "6020499"
        },
        "provided_name": "renda"
      }
    }
  }
}

DELETE /renda

{
  "acknowledged": true
}

GET /renda

{
  "error": {
    "root_cause": [
      {
        "type": "index_not_found_exception",
        "reason": "no such index",
        "resource.type": "index_or_alias",
        "resource.id": "renda",
        "index_uuid": "_na_",
        "index": "renda"
      }
    ],
    "type": "index_not_found_exception",
    "reason": "no such index",
    "resource.type": "index_or_alias",
    "resource.id": "renda",
    "index_uuid": "_na_",
    "index": "renda"
  },
  "status": 
}

PUT /索引库名/_mapping/typeName
{
  "properties": {
    "字段名": {
      "type": "类型",
      "index": true，
      "store": true，
      "analyzer": "分词器"
    }
  }
}

PUT renda/_mapping/goods
{
  "properties": {
    "title": {
      "type": "text",
      "store": true, 
      "analyzer": "ik_max_word"
    },
    "images": {
      "type": "keyword", 
      "store": true, 
      "index": false
    },
    "price": {
      "type": "float"
    }
  }
}

{
  "acknowledged": true
}

GET /索引库名/_mapping

GET /索引库名/_mapping/类型名

GET /renda/_mapping/goods

{
  "renda": {
    "mappings": {
      "goods": {
        "properties": {
          "images": {
            "type": "keyword",
            "index": false,
            "store": true
          },
          "price": {
            "type": "float"
          },
          "title": {
            "type": "text",
            "store": true,
            "analyzer": "ik_max_word"
          }
        }
      }
    }
  }
}

核心类型: 
字符串类型 - text,keyword - 结构化搜索，全文文本搜索、聚合、排序等
整数类型 - integer,long,short,byte - 字段的长度越短，索引和搜索的效率越高
浮点类型 - double,float,half_float,scaled_float
逻辑类型 - boolean
日期类型 - date
范围类型 - range
二进制类型 - binary 
  该 binary 类型接受二进制值作为 Base64 编码的字符串。
  该字段默认情况下不存储(store)，并且不可搜索。

复合类型：
数组类型 - array
对象类型 - object - 用于单个 JSON 对象
嵌套类型 - nested - 用于 JSON 对象数组

地理类型：
地理坐标类型 - geo_point - 纬度/经度积分
地理地图 - geo_shape - 用于多边形等复杂形状

特殊类型：
IP 类型 - ip - 用于 IPv4 和 IPv6 地址
范围类型 - completion - 提供自动完成建议
令牌计数类型 - token_count - 计算字符串中令牌的数量

"properties": {
    "title":{
        "type": "text",
        "analyzer": "ik_max_word",
        "fields": {
            "sort": {
                "type": "keyword"
            }
        },
        "index": true
    }
}

字符串数组：["one", "two"]
整数数组：[1, 2]
数组的数组：[1, [2, 3]]，等价于 [1,2,3]
对象数组：[{"name": "Mary", "age": 12}, {"name": "John", "age": 10}]

{
    "region": "US",
    "manager.age": ,
    "manager.name ": "John Smith"
}

索引方法如下：

{
    "mappings": {
        "properties": {
            "region": { "type": "keyword" },
            "manager": {
                "properties": {
                    "age": { "type": "integer" },
                    "name": { "type": "text" }
                }
            }
        }
    }
}

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
                "ip_addr": {
                    "type": "ip"
                }
            }
        }
    }
}

PUT my_index/_doc/
{
    "ip_addr": "192.168.1.1"
}

GET my_index/_search
{
    "query": {
        "term": {
            "ip_addr": "192.168.0.0/16"
        }
    }
}

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
                "title": {
                    "type": "text",
                    "store": true 
                },
                "date": {
                    "type": "date",
                    "store": true 
                },
                "content": {
                    "type": "text"
                }
            }
        }
    }
}

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
                "title": {
                    "type": "text",
                    "boost":  
                },
                "content": {
                    "type": "text"
                }
            }
        }
    }
}

第一步：
PUT /renda

第二步：
PUT renda/_mapping/goods
{
  "properties": {
    "title": {
      "type": "text",
      "analyzer": "ik_max_word"
    },
    "images": {
      "type": "keyword",
      "index": "false"
    },
    "price": {
      "type": "float"
    }
  }
}

put /索引库名
{
    "settings":{
        "索引库属性名":"索引库属性值"
    },
    "mappings":{
        "类型名":{
            "properties":{
                "字段名":{
                    "映射属性名":"映射属性值"
                }
            }
        }
    }
}

PUT /renda
{
    "settings": {}, 
    "mappings": {
        "goods": {
            "properties": {
                "title": {
                    "type": "text",
                    "analyzer": "ik_max_word"
                }
            }
        }
    }
}

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "renda2"
}

POST /索引库名/类型名
{
    "key":"value"
}

POST /renda/goods/
{
    "title": "小米手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 2699.00
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "gPeQqHUB-UTJAEEuqOm9",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

GET /renda/goods/gPeQqHUB-UTJAEEuqOm

{
  "_index": "renda",
  "_type": "goods",
  "_id": "gPeQqHUB-UTJAEEuqOm9",
  "_version": ,
  "found": true,
  "_source": {
    "title": "小米手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 
  }
}

POST /索引库名/类型/id值
{
    ...
}

POST /renda/goods/
{
    "title": "白米手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 2699.00
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "2",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

PUT /renda/goods/
{
    "title": "黑米手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 3999.00,
    "stock": ,
    "saleable": true
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "3",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

PUT /renda/goods/
{
    "title": "X米手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 4999.00,
    "stock": ,
    "saleable": true
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "3",
  "_version": ,
  "result": "updated",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

DELETE /索引库名/类型名/id值

DELETE /renda/goods/

{
  "_index": "renda",
  "_type": "goods",
  "_id": "3",
  "_version": ,
  "result": "deleted",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

POST /renda/goods/
{
    "title":"超大米手机",
    "images":"http://image.renda.com/12479122.jpg",
    "price":3299.00,
    "stock": ,
    "saleable":true, 
    "subTitle":"大米"
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "3",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

{
  "renda": {
    "aliases": {},
    "mappings": {
      "goods": {
        "properties": {
          "images": {
            "type": "keyword",
            "index": false,
            "store": true
          },
          "price": {
            "type": "float"
          },
          "saleable": {
            "type": "boolean"
          },
          "stock": {
            "type": "long"
          },
          "subTitle": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 
              }
            }
          },
          "title": {
            "type": "text",
            "store": true,
            "analyzer": "ik_max_word"
          }
        }
      }
    },
    "settings": {
      "index": {
        "creation_date": "1604847840423",
        "number_of_shards": "5",
        "number_of_replicas": "1",
        "uuid": "w-Q9ingUTjm2MsfaQ0730g",
        "version": {
          "created": "6020499"
        },
        "provided_name": "renda"
      }
    }
  }
}

PUT renda
{
    "mappings": {
        "goods": {
            "properties": {
                "title": {
                    "type": "text",
                    "analyzer": "ik_max_word",
                    "index": true,
                    "store": true
                }
            },
            "dynamic_templates": [
                {
                    "strings": {
                        "match_mapping_type": "string",
                        "mapping": {
                            "type": "keyword",
                            "index": false,
                            "store": true
                        }
                    }
                }
            ]
        }
    }
}

{
  "acknowledged": true,
  "shards_acknowledged": true,
  "index": "renda3"
}

POST /renda/goods/
{
    "title":"X米手机",
    "images":"http://image.renda.com/12479122.jpg",
    "price":3299.00
}

{
  "_index": "renda3",
  "_type": "goods",
  "_id": "1",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

GET /renda3/_mapping

{
  "renda3": {
    "mappings": {
      "goods": {
        "dynamic_templates": [
          {
            "strings": {
              "match_mapping_type": "string",
              "mapping": {
                "index": false,
                "store": true,
                "type": "keyword"
              }
            }
          }
        ],
        "properties": {
          "images": {
            "type": "keyword",
            "index": false,
            "store": true
          },
          "price": {
            "type": "float"
          },
          "title": {
            "type": "text",
            "store": true,
            "analyzer": "ik_max_word"
          }
        }
      }
    }
  }
}

GET /索引库名/_search
{
    "query":{
        "查询类型":{
            "查询条件":"查询条件值"
        }
    }
}

GET /renda/_search
{
    "query":{
        "match_all": {}
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "2",
        "_score": ,
        "_source": {
          "title": "白米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": ,
        "_source": {
          "title": "小米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "3",
        "_score": ,
        "_source": {
          "title": "超大米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": ,
          "stock": ,
          "saleable": true,
          "subTitle": "大米"
        }
      }
    ]
  }
}

took - 检索所耗费的时间，单位是毫秒。

timed_out - 是否超时。

_shards - 分片信息。

hits - 命中结果，检索结果信息。
  total - 搜索到的总条数。
  max_score - 所有结果中文档得分的最高分。
  hits - 搜索结果的文档对象数组，每个元素是一条搜索到的文档信息。
    _index - 索引库。
    _type - 文档类型。
    _id - 文档 id。
    _score - 评分；索引库的一个概念；关联度。
    _source - 原始数据。

PUT /renda/goods/
{
    "title": "小米电视4A",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 3899.00
}

GET /renda/_search
{
  "query": {
    "match": {
      "title": "小米电视"
    }
  }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": 0.5753642,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "3",
        "_score": 0.5753642,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": 0.2876821,
        "_source": {
          "title": "小米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

GET /renda/_search
{
  "query": {
    "match": {
      "title": {
        "query": "小米电视",
        "operator": "and"
      }
    }
  }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": 0.5753642,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "3",
        "_score": 0.5753642,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

GET /renda/_search
{
    "query":{
        "term":{
            "price": 2699.00
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "2",
        "_score": ,
        "_source": {
          "title": "白米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": ,
        "_source": {
          "title": "小米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

GET /renda/_search
{
    "query":{
        "bool":{
            "must": {
              "match": {
                "title": "小米"
              }
            },
            "must_not": {
              "match": {
                "title": "电视"
              }
            },
            "should": {
              "match": {
                "title": "手机"
              }
            }
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": 0.5753642,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": 0.5753642,
        "_source": {
          "title": "小米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

GET /renda/_search
{
    "query": {
        "range": {
            "price": {
                "gte": 3000.0,
                "lt": 4000.00
            }
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "3",
        "_score": ,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

POST /renda/goods/
{
    "title": "Apple手机",
    "images": "http://image.renda.com/12479122.jpg",
    "price": 6899.00
}

{
  "_index": "renda",
  "_type": "goods",
  "_id": "5",
  "_version": ,
  "result": "created",
  "_shards": {
    "total": ,
    "successful": ,
    "failed": 
  },
  "_seq_no": ,
  "_primary_term": 
}

GET /renda/_search
{
    "query": {
        "fuzzy": {
            "title": "applas"
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": 0.17260925,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "5",
        "_score": 0.17260925,
        "_source": {
          "title": "Apple手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        }
      }
    ]
  }
}

GET /renda/_search
{
    "_source": ["title","price"],
    "query": {
        "term": {
            "price": 
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "2",
        "_score": ,
        "_source": {
          "price": ,
          "title": "白米手机"
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": ,
        "_source": {
          "price": ,
          "title": "小米手机"
        }
      }
    ]
  }
}

GET /renda/_search
{
    "_source": {
        "includes":["title", "price"]
    },
    "query": {
        "term": {
            "price": 
        }
    }
}

GET /renda/_search
{
    "_source": {
        "excludes": ["images"]
    },
    "query": {
        "term": {
            "price": 
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "2",
        "_score": ,
        "_source": {
          "price": ,
          "title": "白米手机"
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": ,
        "_source": {
          "price": ,
          "title": "小米手机"
        }
      }
    ]
  }
}

GET /renda/_search
{
    "query":{
        "bool":{
            "must":{ "match": { "title": "小米手机" }},
            "filter":{
                "range":{"price":{"gt":2000.00,"lt":3800.00}}
            }
        }
    }
}

GET /renda/_search
{
    "query":{
        "constant_score": {
            "filter": {
                "range": {"price":{"gt":2000.00, "lt":3000.00}}
            }
        }
    }
}

GET /renda/_search
{
    "query": {
        "match": {
            "title": "小米手机"
        }
    },
    "sort": [
        {
            "price": {
                "order": "desc"
            }
        }
    ]
}

GET /renda/_search
{
    "query":
    {
        "bool":
        {
            "must":
            {
              "match":
              {
                "title": "小米手机"
              }
            },
            "filter":{
                "range":
                {
                  "price":
                  {
                    "gt":,
                    "lt":
                  }
                }
            }
        }
    },
    "sort": [
        {
          "price":
          {
            "order": "desc"
          }
        },
        {
          "_score":
          {
            "order": "desc"
          }

        }
    ]
}

GET /renda/_search
{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "price": {
                "order": "asc"
            }
        }
    ],
    "from": ,
    "size": 
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": null,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "5",
        "_score": null,
        "_source": {
          "title": "Apple手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        },
        "sort": [
          
        ]
      }
    ]
  }
}

GET /renda/_search
{
    "query": {
        "match": {
            "title": "手机"
        }
    },
    "highlight": {
        "pre_tags": "<em>",
        "post_tags": "</em>", 
        "fields": {
            "title": {}
        }
    }
}

pre_tags：前置标签
post_tags：后置标签
fields：需要高亮的字段
  title：这里声明 title 字段需要高亮

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": 0.2876821,
    "hits": [
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "5",
        "_score": 0.2876821,
        "_source": {
          "title": "Apple手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        },
        "highlight": {
          "title": [
            "Apple<em>手机</em>"
          ]
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "2",
        "_score": 0.2876821,
        "_source": {
          "title": "白米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        },
        "highlight": {
          "title": [
            "白米<em>手机</em>"
          ]
        }
      },
      {
        "_index": "renda",
        "_type": "goods",
        "_id": "gPeQqHUB-UTJAEEuqOm9",
        "_score": 0.2876821,
        "_source": {
          "title": "小米手机",
          "images": "http://image.renda.com/12479122.jpg",
          "price": 
        },
        "highlight": {
          "title": [
            "小米<em>手机</em>"
          ]
        }
      }
    ]
  }
}

PUT /car
{
    "mappings": {
        "orders": {
            "properties": {
                "color": {
                    "type": "keyword"
                },
                "make": {
                    "type": "keyword"
                }
            }
        }
    }
}

POST /car/orders/_bulk
{ "index": {}}
{ "price" : , "color" : "红", "make" : "本田", "sold" : "2020-10-28" }
{ "index": {}}
{ "price" : , "color" : "红", "make" : "本田", "sold" : "2020-11-05" }
{ "index": {}}
{ "price" : , "color" : "绿", "make" : "福特", "sold" : "2020-05-18" }
{ "index": {}}
{ "price" : , "color" : "蓝", "make" : "丰田", "sold" : "2020-07-02" }
{ "index": {}}
{ "price" : , "color" : "绿", "make" : "丰田", "sold" : "2020-08-19" }
{ "index": {}}
{ "price" : , "color" : "红", "make" : "本田", "sold" : "2020-11-05" }
{ "index": {}}
{ "price" : , "color" : "红", "make" : "宝马", "sold" : "2020-01-01" }
{ "index": {}}
{ "price" : , "color" : "蓝", "make" : "福特", "sold" : "2020-02-12" }

GET /car/_search
{
    "size" : ,
    "aggs" : { 
        "popular_colors" : { 
            "terms" : { 
                "field" : "color"
            }
        }
    }
}

size：查询条数，这里设置为 0，因为不关心搜索到的数据，只关心聚合结果，提高效率
aggs：声明这是一个聚合查询，是 aggregations 的缩写
  popular_colors：给这次聚合起一个名字，可任意指定
    terms：聚合的类型，这里选择 terms，是根据词条内容（这里是颜色）划分
      field：划分桶时依赖的字段

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": []
  },
  "aggregations": {
    "popular_colors": {
      "doc_count_error_upper_bound": ,
      "sum_other_doc_count": ,
      "buckets": [
        {
          "key": "红",
          "doc_count": 
        },
        {
          "key": "绿",
          "doc_count": 
        },
        {
          "key": "蓝",
          "doc_count": 
        }
      ]
    }
  }
}

hits：查询结果为空，因为设置了 size 为 
aggregations：聚合的结果
popular_colors：定义的聚合名称
buckets：查找到的桶，每个不同的 color 字段值都会形成一个桶
  key：这个桶对应的 color 字段的值
  doc_count：这个桶中的文档数量

GET /car/_search
{
    "size" : ,
    "aggs" : {
        "popular_colors" : {
            "terms" : {
                "field" : "color"
            },
            "aggs":{
                "avg_price": { 
                    "avg": {
                        "field": "price" 
                    }
                }
            }
        }
    }
}

{
  "took": ,
  "timed_out": false,
  "_shards": {
    "total": ,
    "successful": ,
    "skipped": ,
    "failed": 
  },
  "hits": {
    "total": ,
    "max_score": ,
    "hits": []
  },
  "aggregations": {
    "popular_colors": {
      "doc_count_error_upper_bound": ,
      "sum_other_doc_count": ,
      "buckets": [
        {
          "key": "红",
          "doc_count": ,
          "avg_price": {
            "value": 
          }
        },
        {
          "key": "绿",
          "doc_count": ,
          "avg_price": {
            "value": 
          }
        },
        {
          "key": "蓝",
          "doc_count": ,
          "avg_price": {
            "value": 
          }
        }
      ]
    }
  }
}

完整索引库indices ----> [分片shard1, 分片shard2, 分片shard3]

创建索引，分为三个分片，
将每个分片放在不同的集群节点中，以此实现高存储。

node-01 : 0, 2
node-02 : 0, 1
node-03 : 1, 2

集群有三个节点，分别是 node-01、node-02、node-03；
新建索引 renda，指定分片为 3，副本为 1，三个主数据，三个副本；
三个分片为 0，1，2。

0 对应 node-01，
1 对应 node-02，
2 对应 node-03，

# 允许跨域名访问
http.cors.enabled: true
# 当设置允许跨域，默认为*,表示支持所有域名
http.cors.allow-origin: "*"
# 允许所有节点访问
network.host: 0.0.0.0
# 集群的名称，同一个集群下所有节点的集群名称应该一致
cluster.name: renda-elastic
# 当前节点名称 每个节点不一样
node.name: node-01
# 数据的存放路径 每个节点不一样，不同 es 服务器对应的 data 和 log 存储的路径不能一样
path.data: e:\class\es-9201\data
# 日志的存放路径 每个节点不一样
path.logs: e:\class\es-9201\logs
# http协议的对外端口 每个节点不一样，默认：9200
http.port: 9201
# TCP协议对外端口 每个节点不一样，默认：9300
transport.tcp.port: 9301
# 三个节点相互发现，包含自己，使用 tcp 协议的端口号
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
# 声明大于几个的投票主节点有效，请设置为（nodes / 2） + 1
discovery.zen.minimum_master_nodes: 2
# 是否为主节点
node.master: true

# 允许跨域名访问
http.cors.enabled: true
http.cors.allow-origin: "*"
network.host: 0.0.0.0
# 集群的名称
cluster.name: renda-elastic
# 当前节点名称 每个节点不一样
node.name: node-02
# 数据的存放路径 每个节点不一样
path.data: e:\class\es-9202\data
# 日志的存放路径 每个节点不一样
path.logs: e:\class\es-9202\logs
# http 协议的对外端口 每个节点不一样
http.port: 9202
# TCP 协议对外端口 每个节点不一样
transport.tcp.port: 9302
# 三个节点相互发现
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
# 声明大于几个的投票主节点有效，请设置为（nodes / 2） + 1
discovery.zen.minimum_master_nodes: 2
# 是否为主节点
node.master: true

# 允许跨域名访问
http.cors.enabled: true
http.cors.allow-origin: "*"
network.host: 0.0.0.0
# 集群的名称
cluster.name: renda-elastic
# 当前节点名称 每个节点不一样
node.name: node-03
# 数据的存放路径 每个节点不一样
path.data: e:\class\es-9203\data
# 日志的存放路径 每个节点不一样
path.logs: e:\class\es-9203\logs
# http协议的对外端口 每个节点不一样
http.port: 9203
# TCP协议对外端口 每个节点不一样
transport.tcp.port: 9303
# 三个节点相互发现
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]
# 声明大于几个的投票主节点有效，请设置为（nodes / 2） + 1
discovery.zen.minimum_master_nodes: 2
# 是否为主节点
node.master: true

# 端口号改为 9201 或 9202 或 9203 都可以
elasticsearch.url: "http://localhost:9201"

PUT /renda
{
    "settings": {
        "number_of_shards": ,
        "number_of_replicas": 
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.renda</groupId>
    <artifactId>elasticsearch-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>elasticsearch-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>
        <!-- Apache 开源组织提供的用于操作 JAVA BEAN 的工具包 -->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- ES 高级 Rest Client -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>6.4.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

@Data
public class Product {

    private Long id;

    private String title; // 标题

    private String category; // 分类

    private String brand; // 品牌

    private Double price; // 价格

    private String images; // 图片地址

}

PUT /renda
{
    "settings": {
        "number_of_shards": ,
        "number_of_replicas": 
    }, 
    "mappings": {
        "item": {
            "properties": {
                "id": {
                    "type": "keyword"
                },
                "title": {
                    "type": "text",
                    "analyzer": "ik_max_word"
                },
                "category": {
                    "type": "keyword"
                },
                "brand": {
                    "type": "keyword"
                },
                "images": {
                    "type": "keyword",
                    "index": false
                },
                "price": {
                    "type": "double"
                }
            }
        }
    }
}

@SpringBootTest
@RunWith(SpringRunner.class)
class ElasticsearchDemoApplicationTests {

    private RestHighLevelClient restHighLevelClient;

    /**
     * 初始化客户端
     */
    @Before
    public void init() {
        RestClientBuilder restClientBuilder = RestClient.builder(
                new HttpHost("127.0.0.1", , "http"),
                new HttpHost("127.0.0.1", , "http"),
                new HttpHost("127.0.0.1", , "http")
        );
        restHighLevelClient = new RestHighLevelClient(restClientBuilder);
    }

    /**
     * 关闭客户端
     */
    @After
    public void close() throws IOException {
        restHighLevelClient.close();
    }

}

package com.renda;

import com.google.gson.Gson;
import com.renda.pojo.Product;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ElasticsearchDemoApplicationTests {

    private RestHighLevelClient restHighLevelClient;
    private Gson gson = new Gson();

    ...

    /**
     * 插入文档
     */
    @Test
    public void testInsert() throws IOException {
        // 1.文档数据
        Product product = new Product();
        product.setBrand("华为");
        product.setCategory("手机");
        product.setId(1L);
        product.setImages("http://image.huawei.com/1.jpg");
        product.setPrice(5999.99);
        product.setTitle("华为P30");
        // 2.将文档数据转换为 json 格式
        String source = gson.toJson(product);
        // 3.创建索引请求对象 访问哪个索引库、哪个 type、指定文档 ID
        // public IndexRequest(String index, String type, String id)
        IndexRequest request = new IndexRequest("renda", "item", product.getId().toString());
        request.source(source, XContentType.JSON);
        // 4.发出请求
        IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
        System.out.println(response);
    }

}

IndexResponse[
    index=renda,
    type=item,
    id=,
    version=,
    result=updated,
    seqNo=,
    primaryTerm=,
    shards={
        "total":,
        "successful":,
        "failed":
    }
]

...

/**
 * 查看文档
 */
@Test
public void testView() throws IOException {
    // 初始化 GetRequest 对象
    GetRequest getRequest = new GetRequest("renda", "item", "1");
    // 执行查询
    GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
    // 取出数据
    String source = getResponse.getSourceAsString();
    Product product = gson.fromJson(source, Product.class);
    System.out.println(product);
}

...

Product(
    id=, 
    title=华为P, 
    category=手机, 
    brand=华为, 
    price=5999.99, 
    images=http://image.huawei.com/1.jpg
)

/**
 * 删除文档
 */
@Test
public void testDelete() throws IOException {
    // 初始化 DeleteRequest 对象
    DeleteRequest request = new DeleteRequest("renda", "item", "1");
    // 执行删除
    DeleteResponse response = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
    System.out.println(response);
}

DeleteResponse[
    index=renda,
    type=item,
    id=,
    version=,
    result=deleted,
    shards=ShardInfo
    {
        total=2, 
        successful=2, 
        failures=[]
    }
]

/**
 * 可重用代码
 */
public void baseQuery(SearchSourceBuilder sourceBuilder) throws IOException {
    // 创建搜索请求对象
    SearchRequest request = new SearchRequest();
    // 查询构建工具
    request.source(sourceBuilder);
    // 执行查询
    SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    // 获得查询结果
    SearchHits hits = response.getHits();
    // 获得文件数组
    SearchHit[] hitsHits = hits.getHits();
    for(SearchHit searchHit: hitsHits){
        String json = searchHit.getSourceAsString();
        // 将 json 反序列化为 Product 格式
        Product product = gson.fromJson(json, Product.class);
        System.out.println(product);
    }
}

/**
 * 查看所有文档
 */
@Test
public void matchAll() throws IOException {
    // 查询构建工具
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 添加查询条件，执行查询类型
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    // 调用基础查询方法
    baseQuery(sourceBuilder);
}

item = Item{id=5, title='荣耀V10', category='手机', brand='华为', price=2799.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=2, title='坚果手机R1', category='手机', brand='锤子', price=3699.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=4, title='小米Mix2S', category='手机', brand='小米', price=4299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=1, title='小米手机7', category='手机', brand='小米', price=3299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=3, title='华为META10', category='手机', brand='华为', price=4499.0, images='http://image.renda.com/13123.jpg'}

@Test
public void matchQuery() throws IOException {
    SearchSourceBuilder builder = new SearchSourceBuilder();
    // 设置查询类型和查询条件
    builder.query(QueryBuilders.matchQuery("title", "手机"));
    // 调用基础查询方法
    baseQuery(builder);
}

item = Item{id=2, title='坚果手机R1', category='手机', brand='锤子', price=3699.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=1, title='小米手机7', category='手机', brand='小米', price=3299.0, images='http://image.renda.com/13123.jpg'}

RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");

@Test
public void rangeQuery() throws IOException {
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 执行查询条件和查询类型
    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");
    rangeQueryBuilder.gte();
    rangeQueryBuilder.lte();
    sourceBuilder.query(rangeQueryBuilder);
    baseQuery(sourceBuilder);
}

item = Item{id=5, title='荣耀V10', category='手机', brand='华为', price=2799.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=2, title='坚果手机R1', category='手机', brand='锤子', price=3699.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=1, title='小米手机7', category='手机', brand='小米', price=3299.0, images='http://image.renda.com/13123.jpg'}

@Test
public void sourceFilter() throws IOException {
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 执行查询条件和查询类型
    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");
    rangeQueryBuilder.gte();
    rangeQueryBuilder.lte();
    sourceBuilder.query(rangeQueryBuilder);
    // source 过滤，只保留 id、title、price
    sourceBuilder.fetchSource(new String[]{"id", "title", "price"}, null);
    baseQuery(sourceBuilder);
}

item = Item{id=5, title='荣耀V10', category='null', brand='null', price=2799.0, images='null'}
item = Item{id=2, title='坚果手机R1', category='null', brand='null',  price=3699.0, images='null'}
item = Item{id=4, title='小米Mix2S', category='null', brand='null', price=4299.0, images='null'}
item = Item{id=1, title='小米手机7', category='null', brand='null', price=3299.0, images='null'}
item = Item{id=3, title='华为META10', category='null', brand='null',  price=4499.0, images='null'}

@Test
public void sortAndPage() throws IOException {
    // 创建搜索请求对象
    SearchRequest request = new SearchRequest();
    // 查询构建工具
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 添加查询条件，执行查询类型
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    // 执行排序 价格降序排序
    sourceBuilder.sort("price", SortOrder.DESC);

    baseQuery(sourceBuilder);
}

item = Item{id=, title='荣耀V10', category='手机', brand='华为', price=2799.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='小米手机7', category='手机', brand='小米', price=3299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='坚果手机R1', category='手机', brand='锤子', price=3699.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='小米Mix2S', category='手机', brand='小米', price=4299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='华为META10', category='手机', brand='华为', price=4499.0, images='http://image.renda.com/13123.jpg'}

@Test
public void sortAndPage() throws IOException {
    // 创建搜索请求对象
    SearchRequest request = new SearchRequest();
    // 查询构建工具
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 添加查询条件，执行查询类型
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    // 执行排序 价格降序排序
    sourceBuilder.sort("price", SortOrder.DESC);

    // 分页信息
    int currentPage = ;
    int pageSize = ;
    int startPos = (currentPage - ) * pageSize;
    //设置分页
    sourceBuilder.from(startPos);
    sourceBuilder.size();

    baseQuery(sourceBuilder);
}

item = Item{id=, title='荣耀V10', category='手机', brand='华为', price=2799.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='小米手机7', category='手机', brand='小米', price=3299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='坚果手机R1', category='手机', brand='锤子', price=3699.0, images='http://image.renda.com/13123.jpg'}

item = Item{id=, title='小米Mix2S', category='手机', brand='小米', price=4299.0, images='http://image.renda.com/13123.jpg'}
item = Item{id=, title='华为META10', category='手机', brand='华为', price=4499.0, images='http://image.renda.com/13123.jpg'}

<!-- Spring data elasticsearch -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

spring:
  data:
    elasticsearch:
      cluster-name: renda-elastic
      cluster-nodes: 127.0.0.1:9301,127.0.0.1:9302,127.0.0.1:9303

@SpringBootApplication
public class ElasticsearchDemoApplication {

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

}

@Data
public class Product {

    private Long id;

    private String title; // 标题

    private String category; // 分类

    private String brand; // 品牌

    private Double price; // 价格

    private String images; // 图片地址

}

@RunWith(SpringRunner.class)
@SpringBootTest
public class ElasticsearchSpringDataTests {

    @Autowired
    private ElasticsearchTemplate template;

}

@RunWith(SpringRunner.class)
@SpringBootTest
public class ElasticsearchSpringDataTests {

    @Autowired
    private ElasticsearchTemplate template;

    @Test
    public void createIndex() {
        template.createIndex(Product.class);
    }

}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(indexName = "renda", type = "product", shards = , replicas = )
public class Product {

    @Id
    private Long id;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String title; // 标题

    @Field(type = FieldType.Keyword)
    private String category; // 分类

    @Field(type = FieldType.Keyword)
    private String brand; // 品牌

    @Field(type = FieldType.Double)
    private Double price; // 价格

    @Field(type = FieldType.Keyword, index = false)
    private String images; // 图片地址

}

@Test
public void createType() {
    template.putMapping(Product.class);
}

package com.renda.repository;

import com.renda.pojo.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * 当 SDE 访问索引库时，
 * 需要定义一个持久层的接口去继承 ElasticsearchRepository 接口即可，
 * 无需实现
 *
 * @author Renda Zhang
 * @since 2020-11-10 23:00
 */
public interface ProductRepository extends ElasticsearchRepository<Product, Long> {
}

@Test
public void insertDocument() {
    Product product = new Product(6L, "小米手机", "手机", "锤子", 3299.99, "http://image.renda.com/1.jpg");
    productRepository.save(product);
    System.out.println("Successfully Saved");
}

@Test
public void insertDocuments() {
    Product product1 = new Product(2L, "坚果手机", "手机", "phone", 3299.99, "http://image.renda.com/1.jpg");
    Product product2 = new Product(3L, "华为手机", "手机", "phone", 3299.99, "http://image.renda.com/1.jpg");
    Product product3 = new Product(4L, "苹果手机", "手机", "phone", 3299.99, "http://image.renda.com/1.jpg");
    Product product4 = new Product(5L, "索尼手机", "手机", "phone", 3299.99, "http://image.renda.com/1.jpg");
    List<Product> list = new ArrayList<>();
    list.add(product1);
    list.add(product2);
    list.add(product3);
    list.add(product4);
    productRepository.saveAll(list);
    System.out.println("Successfully Saved All");
}

@Test
public void findById() {
    Optional<Product> optional = productRepository.findById(3L);
    // orElse 方法的作用：如果 optional 中封装的实体对象为空也就是没有从索引库中查询出匹配的文档，返回 orElse 方法的参数
    Product product = optional.orElse(null);
    System.out.println(product);
}

Product(id=, title=华为手机, category=手机, brand=phone, price=3299.99, images=http://image.renda.com/1.jpg)

@Test
public void findAll() {
    productRepository.findAll().forEach(System.out::println);
}

Product(id=, title=小米手机, category=手机, brand=锤子, price=3299.99, images=http://image.renda.com/1.jpg)
Product(id=, title=坚果手机, category=手机, brand=phone, price=3299.99, images=http://image.renda.com/1.jpg)
Product(id=, title=苹果手机, category=手机, brand=phone, price=3299.99, images=http://image.renda.com/1.jpg)
Product(id=, title=索尼手机, category=手机, brand=phone, price=3299.99, images=http://image.renda.com/1.jpg)
Product(id=, title=华为手机, category=手机, brand=phone, price=3299.99, images=http://image.renda.com/1.jpg)

public interface ProductRepository extends ElasticsearchRepository<Product, Long> {

    /**
     * 查询价格范围
     */
    List<Product> findByPriceBetween(Double from, Double to);

}

@Test
public void findByPrice() {
    List<Product> list = productRepository.findByPriceBetween(2000.00, 4000.00);
    System.out.println(list.size());
}

And 
findByNameAndPrice
{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}

Or 
findByNameOrPrice
{"bool" : {"should" : [{"field" : {"name" : "?"}}, {"field" : {"price" : "?"}}]}}

Is 
findByName
{"bool" : {"must" : {"field" :{"name" : "?"}}}}

Not 
findByNameNot
{"bool" : {"must_not" :{"field" : {"name" : "?"}}}}

Between 
findByPriceBetween
{"bool" : {"must" : {"range" : {"price" : {"from" : ?, "to" : ?, "include_lower" : true, "include_upper" : true}}}}}

LessThanEqual
findByPriceLessThan
{"bool" : {"must" : {"range" :{"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true}}}}}

GreaterThanEqual 
findByPriceGreaterThan
{"bool" : {"must" : {"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true}}}}}

Before 
findByPriceBefore
{"bool" : {"must" : {"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true}}}}}

After 
findByPriceAfter
{"bool" : {"must" : {"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true}}}}}

Like 
findByNameLike
{"bool" : {"must" : {"field" : {"name" : {"query" : "?*", "analyze_wildcard" : true}}}}}

StartingWith 
findByNameStartingWith
{"bool" : {"must" : {"field" : {"name" : {"query" : "?*", "analyze_wildcard" : true}}}}}

EndingWith 
findByNameEndingWith
{"bool" : {"must" : {"field" : {"name" : {"query" : "*?", "analyze_wildcard" : true}}}}}

Contains/Containing 
findByNameContaining
{"bool" : {"must" : {"field" : {"name" : {"query" : "**?**", "analyze_wildcard" : true}}}}}

In 
findByNameIn(Collection<String>names)
{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}

NotIn 
findByNameNotIn(Collection<String>names)
{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}

Near 
findByStoreNear 
Not Supported Yet !

True 
findByAvailableTrue
{"bool" : {"must" : {"field" : {"available" : true}}}}

False 
findByAvailableFalse
{"bool" : {"must" : {"field" : {"available" : false}}}}

OrderBy 
findByAvailableTrueOrderByNameDesc
{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}

@Test
public void nativeQuery() {
    // 1.构架一个原生查询器
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 2.source 过滤
    // 2.1 参数：final String[] includes, final String[] excludes
    // 如果不想执行 source 过滤可以将该行注释
    queryBuilder.withSourceFilter(new FetchSourceFilter(new String[], new String[]));
    // 3.查询条件
    queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
    // 4.设置分页和排序规则
    queryBuilder.withPageable(PageRequest.of(, , Sort.by(Sort.Direction.ASC, "price")));
    // 5.高亮
    // ...
    // 6.聚合
    queryBuilder.addAggregation(AggregationBuilders.terms("brandAgg").field("brand"));
    // 7.查询
    AggregatedPage<Product> result = template.queryForPage(queryBuilder.build(), Product.class);

    // 8. 解析结果
    // 获取分页结果
    long total = result.getTotalElements();
    int totalPages = result.getTotalPages();
    List<Product> content = result.getContent();
    System.out.println(total + "  " + totalPages);
    content.forEach(System.out::println);
    // 获取聚合结果
    Aggregations resultAggregations = result.getAggregations();
    Terms terms = resultAggregations.get("brandAgg");
    terms.getBuckets().forEach(bucket -> {
        System.out.println("品牌：" + bucket.getKeyAsString());
        System.out.println("数量：" + bucket.getDocCount());
    });
}

package com.renda.resultMapper;

import com.google.gson.Gson;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.SearchResultMapper;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;

import java.util.ArrayList;
import java.util.Map;

/**
 * 自定义结果映射，处理高亮
 *
 * @author Renda Zhang
 * @since 2020-11-10 23:50
 */
public class ESSearchResultMapper implements SearchResultMapper {

    /**
     * 完成结果映射
     * 操作的重点应该是将原有的结果：_source 取出来，放入高亮的数据
     *
     * @return AggregatedPage 需要三个参数进行构建：pageable, List<Product>, 总记录数
     */
    @Override
    public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
        // 获得总记录数
        SearchHits searchHits = searchResponse.getHits();
        if (searchHits.getHits().length <= ) {
            return null;
        }

        // 记录列表
        ArrayList<T> list = new ArrayList<>();
        // 获取原始的搜索结果
        for (SearchHit hit : searchHits) {
            // 获取 _source 属性中的所有数据
            Map<String, Object> map = hit.getSourceAsMap();
            // 获得高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            // 每个高亮字段都需要进行设置
            for (Map.Entry<String, HighlightField> highlightField : highlightFields.entrySet()) {
                // 获得高亮的 key：高亮字段
                String key = highlightField.getKey();
                // 获得 value：高亮之后的效果
                HighlightField value = highlightField.getValue();
                // 将高亮字段和文本效果放入到 map 中，覆盖对应数据
                map.put(key, value.getFragments()[].toString());
            }
            // 将 map 转换为对象
            // map --> jsonString --> 对象
            Gson gson = new Gson();
            T t = gson.fromJson(gson.toJson(map), aClass);
            list.add(t);
        }

        // 返回
        return new AggregatedPageImpl<>(list, pageable, searchHits.getTotalHits());
    }
}

@Test
public void nativeQuery() {
    // 1.构架一个原生查询器
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    // 2.source 过滤
    // 2.1 参数：final String[] includes, final String[] excludes
    // 如果不想执行 source 过滤可以将该行注释
    queryBuilder.withSourceFilter(new FetchSourceFilter(new String[], new String[]));
    // 3.查询条件
    queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
    // 4.设置分页和排序规则
    queryBuilder.withPageable(PageRequest.of(, , Sort.by(Sort.Direction.DESC, "price")));
    // 5.高亮
    HighlightBuilder.Field field = new HighlightBuilder.Field("title");
    field.preTags("<font style='color:red'>");
    field.postTags("</font>");
    queryBuilder.withHighlightFields(field);
    // 6.聚合
    queryBuilder.addAggregation(AggregationBuilders.terms("brandAgg").field("brand"));
    // 7.查询
    AggregatedPage<Product> result = template.queryForPage(queryBuilder.build(), Product.class, new ESSearchResultMapper());

    // 8. 解析结果
    // 获取分页结果
    long total = result.getTotalElements();
    int totalPages = result.getTotalPages();
    List<Product> content = result.getContent();
    System.out.println(total + "  " + totalPages);
    content.forEach(System.out::println);
}