ElasticSearch入门到进阶

• • 初识ElasticSearch
  • • 基于关系型数据库查询的问题
    • ElasticSearch - 概念介绍
    • ElasticSearch - 倒排索引
    • ElasticSearch - 存储和查询的原理
  • 安装ElasticSearch
  • • 安装ElasticSearch
    • 安装Kibana
  • ElasticSearch核心概念
  • 操作ElasticSearch
  • • RESTful风格介绍
    • 脚本操作ES - 操作索引
    • 脚本操作ES - 操作映射 - 数据类型
    • 脚本操作ES - 操作映射
    • 脚本操作ES - 操作文档
  • 分词器
  • • 分词器 - IK分词器安装
    • 分词器 - IK分词器使用
  • ElasticSearch JavaAPI
  • • SpringBoot整合ElasticSearch
    • Java API - 操作索引
    • 操作文档
  • ElasticSearch高级操作
  • • 批量操作
    • 导入数据
    • 各种查询
    • • matchAll 查询
      • term 查询
      • match 查询
      • 模糊查询
      • 范围查询
      • queryString 查询
      • 布尔查询
      • 聚合查询
      • 高亮查询

初识ElasticSearch

ElasticSearch是一个搜索服务器

说到搜索，大家第一时间想到的是什么？

百度、谷歌、商城的搜索功能…

其实搜索就是查询。 select * from xxx where xxx like %xxx% -> 关系型数据库

那么像上面 百度、谷歌、商城的搜索功能是使用关系型数据库来实现的吗？ 答： 不是

为什么不是呢，那我们来说一下关系型数据库查询的问题

基于关系型数据库查询的问题

以下表为例

1、查询 title 中包含 ‘手机’ 的信息？

SELECT * FROM goods title like '%手机%'

该语句从语义上来说确实是没有问题的。
但是我们都知道，在使用模糊查询，左边有通配符情况下，是不会走索引的，会全表扫描，性能低

2、查询 title 中包含 ‘华为’ 或者 ‘手机’ 的信息？

SELECT * FROM goods title like '%华为手机%'

其实我们想要查询的是 包含华为 或者 包含手机 的信息，那么我们用上述的SQL语句肯定是查询不出来的。

我们 在京东上搜一下“华为手机” 看一下效果

我们会发现搜索出来的内容有 包含 华为 或者 手机 或者 华为手机 这几个关键字的信息

但是如果我们使用关系型数据库，进行模糊查询的话，是比较难实现这个功能的（可以实现，但是相对来说比较复杂）
所以使用关系型数据来实现的查询， 功能是比较弱的

正是因为在海量的数据中执行搜索功能时，使用关系型数据库会出现性能弱、功能低的问题。我们的ElasticSearch就应用而生了。

ElasticSearch - 概念介绍

概念：

• ElasticSearch 是一个基于Lucene的搜索服务器（Lucene：提供一套搜索的API，包含各种jar包、代码）
• 是一个分布式、高扩展、高实时的搜索与数据分析引擎
• 基于RESTful web接口
• ElasticSearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎
• 官网：https://www.elastic.co/

应用场景：

• 搜索：海量数据的查询
• 日志数据分析
• 实时数据分析

ElasticSearch 与 MySQL

• MySQL有事务性，而ElasticSearch 没有事务性，所以你删了的数据是无法恢复的
• ElasticSearch 没有物理外键的这个特性，如果你的数据强一致性要求比较高，还是建议慎用
• ElasticSearch 和 MySQL分工明确，MySQL负责存储数据，ElasticSearch 负责搜索数据

ElasticSearch - 倒排索引

正向索引：

key存储唯一标识符 ,value就存储对应的值

倒排索引：

倒排索引：将各个文档中的内容，进行分词，形成词条。然后记录词条和数据唯一标识（id）的对应关系，形成的产物。

就是将我们存储的数据进行分词，然后将文本按照一定的规则，拆分为不同的词条（term）

例如， “床前明月光”、“明月几时有” 这两个诗句，按照倒排索引来存储

但实际是我们的value值并非存储的是实际的值，一般是对应的唯一标识（这里我们的唯一标识是题目）

ElasticSearch - 存储和查询的原理

安装ElasticSearch

安装ElasticSearch

有一点需要强调，ElasticSearch是由Java开发的，而且内置有jdk，所有你部署的服务器最好是一个没有配置jdk的机器，否则会出现版本不一致等错误 或者 一些奇葩的错误
官网下载网址：
https://www.elastic.co/cn/downloads/?elektra=home&storm=hero

根据自己的需求下载不同的版本
下载完成后将，将下载后的xxx.tar.gz文件 上传到Linux服务器上（一般存放在/opt目录下）

解压安装包

tar -zxvf elasticsearch-7.16.2-linux-x86_64.tar.gz

elasticsearch相关的配置

解压完成之后，我们还需要修改一些配置
进入/opt/elasticsearch-7.16.2/config目录

vi elasticsearch.yml

将如下配置添加到elasticsearch.yml文件的尾部

cluster.name: my-elasticSearch
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: ["node-1"]

cluster.name：配置elasticsearch的集群名称，默认是elasticsearch。建议修改成一个有意义的名称
node.name: 节点名，elasticsearch会默认随机指定一个名字，建议指定一个有意义的名字，方便管理
network.host: 设置0.0.0.0允许外网访问
http.port: elasticsearch的http访问端口
cluster.initial_master_nodes: 初始化新的集群时需要此配置来选举master

创建用户、切换用户

es为了安全考虑，是不允许root用户来启动es，否则启动会报错

创建用户：

useradd  es_coderzpw  # 新增xxx用户
passwd es_coderzpw  # 为xxx用户设置密码

将elasticsearch的文件 授权给xxx用户：

chown -R es_coderzpw:es_coderzpw elasticsearch-7.16.2/

由于新创建的用户最大可创建文件数太小，虚拟机内存太小，我们来添加如下配置：

1、设置最大可创建文件大小

编辑limits.conf文件：

vi /etc/security/limits.conf

尾部添加如下内容：

es_coderzpw soft nofile 65536
es_coderzpw hard nofile 65536

编辑20-nproc.conf文件：

vi /etc/security/limits.d/20-nproc.conf

尾部添加如下内容：

es_coderzpw soft nofile 65536
es_coderzpw hard nofile 65536
* hard nproc 4096

2、设置最大虚拟机内存大小

编辑sysctl.conf文件：

vi /etc/sysctl.conf

尾部添加如下内容：

vm.max_map_count=655360

重新加载配置文件

sysctl -p

这些都修改完成之后，切换到es_coderzpw用户

su es_coderzpw # 切换用户

启动elasticsearch

进入到/opt/elasticsearch-7.16.2/bin目录

cd /opt/elasticsearch-7.16.2/bin

查看目录：

启动该服务

./elasticsearch

会有如下界面

如果没报错，然后浏览器上访问：http://192.168.139.130:9200/

若出现如下信息，则启动成功

若访问不成功，查看一下是否是自己的服务器的防火墙未关闭的原因

安装Kibana

什么是Kibana？

Kibana是一个针对于ElasticSearch的开源分析及可视化平台，用来搜索、查看交互存储在ElasticSearch索引中的数据。使用Kibana，可以通过各种图表进行高级数据分析及展示

Kibana让海量数据更容易理解。它操作简单，基于浏览器的用户界面可以快速创建仪表板（dashboard）实时显示ElasticSearch查询动态。

下载安装

首先下载Kibana文件，并上传到Linux服务器上，一般放到/opt目录下
官网下载网址：
https://www.elastic.co/cn/downloads/?elektra=home&storm=hero

一般放入/opt目录下

解压kibana：

tar -zxvf kibana-7.16.2-linux-x86_64.tar.gz

修改kibana配置：

切换到kibana-7.16.2-linux-x86_64/config目录

cd /opt/kibana-7.16.2-linux-x86_64/config

编辑kibana.yml文件

vi kibana.yml

尾部添加如下内容：

server.port: 5601
server.host: "0.0.0.0"
server.name: "my-kibana"
elasticsearch.hosts: ["http://127.0.0.1:9200"]
elasticsearch.requestTimeout: 99999

启动Kibana服务

进入到/kibana-7.16.2-linux-x86_64/bin目录

cd /opt/kibana-7.16.2-linux-x86_64/bin

如果在root用户下启动其实还是会有问题的

但如果非要在root用户下启动也不是不可以，执行：

./kibana --allow-root

没报错，并出现如下提示就算是启动成功了

紧接着我们在浏览器上访问一下：http://192.168.139.130:5601/

访问成功，然后点击箭头处的小扳手图标

ElasticSearch核心概念

• 索引（index）：ElasticSearch存储数据的地方，可以理解成关系型数据库中的数据库概念
• 映射（mapping）：mapping定义了每个字段的类型、字段所使用的分词器等。相当于关系型数据库中的表结构
• 文档（document）：ElasticSearch中的最小数据单元，常以json格式显示。一个document相当于关系型数据库中的一行数据
• 倒排索引：一个倒排索引由文档中所有不重复词的列表构成，对于其中每个词，对应一个包含它的文档id列表
• 类型（type）：一种type就像一类表。如用户表、角色表等。在ElasticSearch7.X默认type为_doc
  • ES 5.x中一个index可以有多种type
  • ES 6.x中一个index只能有一种type
  • ES 7.x以后，将逐步移除type这个概念，现在的操作已经不再使用，默认_doc

操作ElasticSearch

RESTful风格介绍

REST（Representational State Transfer），表述性状态转移，是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或者设计就是RESTful。就是一组定义接口的规范。

满足要求：

• 可以使用XML格式定义或者JSON格式定义。
• 每一个URI代表一种资源
• 客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：
  • GET： 用来获取资源
  • POST：用来新建资源（也可以用于更新资源）
  • PUT：用来更新资源
  • DELETE：用来删除资源

脚本操作ES - 操作索引

添加索引

添加索引：PUT 索引名称

查询索引

查询索引：GET 索引名称

查询多个索引信息：GET index1,index2

查询所有索引：GET _all
一般以 _ 下划线开头的都是ES中的关键字

删除索引

删除索引：DELETE 索引名称

脚本操作ES - 操作映射 - 数据类型

简单数据类型：

• 字符串
  • text： 会分词（例如存储，“华为手机”，实际上存储“华为、手机”），不支持聚合
  • keyword： 不会分词（例如存储，“华为手机”，存储的就是“华为手机”），将全部内容作为一个词条，支持聚合
• 数值
  • long： 带符号的64位整数
  • integer： 带符号的32位整数
  • short： 带符号的16位整数
  • byte： 带符号的8位整数
  • double： 双精度的64位小数
  • float： 单精度的32位小数
  • half_float：半精度的16位小数
  • scaled_float：由a支持的有限浮点数long，由固定double比例因子缩放
• 布尔
  • boolean
• 二进制
  • binary
• 范围类型
  • integer_range、float_range、long_range、double_range、date_range
• 日期
  • date

复杂数据类型：

• 数组：[]
• 对象：{}

脚本操作ES - 操作映射

添加映射

添加映射（索引已存在的情况）：

PUT person/_mapping
{
  "properties": {
    "name": {
      "type": "keyword"
    },
    "age": {
      "type": "integer"
    }
  }
}

创建索引、同时添加映射：

PUT person
{
  "mappings": {
    "properties": {
      "name": {
        "type": "keyword"
      },
      "age": {
        "type": "integer"
      }
    }
  }
}

查询映射

查询映射：GET person/_mapping

添加字段

为person的映射新增一个字段address

PUT person/_mapping
{
  "properties": {
    "address": {
      "type": "text"
    }
  }
}

脚本操作ES - 操作文档

添加文档

# 添加文档，指定id
PUT person/_doc/1
{
  "name": "小虎牙",
  "age": "22",
  "address": "上海浦东新区"
}

# 添加文档，不指定id
POST person/_doc
{
  "name": "coderzpw",
  "age": "27",
  "address": "上海浦东新区陆家嘴"
}

查询文档

# 查看文档
GET person/_doc/1

# 查询所有文档
GET person/_search

修改文档

修改其实很简单，还是之前的PUT命令 ，id存在的话就是修改
例如将id为1的name改成 “小虎牙123”

PUT person/_doc/1
{
  "name": "小虎牙123",
  "age": "22",
  "address": "上海浦东新区"
}

删除文档

# 根据id删除文档
DELETE person/_doc/Rc8z2H8BdQgQoyyPS84Z

删除id为“Rc8z2H8BdQgQoyyPS84Z”的文档

分词器

ES的数据存到索引库之前需要先分词，形成分词、形成词条、形成倒排索引。

分词器（Analyzer）：将一段文本，按照一定逻辑，分析成多个词语的一种工具。
如：华为手机 -> 华为、手、手机

• ElasticSearch内置分词器
  - Standard Analyzer - 默认分词器，按词切分，小写处理
  - Simple Analyzer - 按照非字母切分（符号被过滤），小写处理
  - Stop Analyzer - 小写处理，停用词过滤（this,a,is）
  - 等

ElasticSearch内置分词器对中文很不友好，处理方式为：一个字一个词

接下来我们来测试一下，使用内置分词器对中文的分词

那么这样的东西呢，我们肯定不能在我们中文的环境下去使用了，很不方便。
我们要用的话，就需要安装一些中文的分词器，例如：IK分词器

IK分词器：

• IKAnalyzer是一个开源的，基于Java语言开发的轻量级的中文分词工具包
• 是一个基于Maven构建的项目
• 具有60万字/秒的高速处理能力
• 支持用户词典扩展定义
• 下载地址：https://github.com/medcl/elasticsearch-analysis-ik

分词器 - IK分词器安装

1、环境准备

ElasticSearch要使用ik，就要先构建ik的jar包，这里要用到maven包管理工具，而maven需要Java环境，而ElasticSearch内置了jdk，所以可以将JAVA_HOME设置为ElasticSearch内置的jdk

设置JAVA_HOME

vi /etc/profile
#在文件末尾添加jdk的环境变量
export JAVA_HOME=/opt/elasticsearch-7.16.2/jdk
export PATH=$PATH:${JAVA_HOME}/bin

#保存退出后，重新加载profile
source /etc/profile

下载maven安装包并解压

maven官网下载地址：https://maven.apache.org/download.cgi

MAVEN_HOME配置

编辑文件

vi /etc/profile.d/maven.sh

将下面的内容复制到文件，保存

export MAVEN_HOME=/opt/apache-maven-3.8.5
export PATH=${MAVEN_HOME}/bin:${PATH}

设置好Maven的路径之后，需要运行下面的命令使其生效

source /etc/profile.d/maven.sh

验证maven是否安装成功

mvn -v

maven 安装成功

2、下载IK分词器

下载地址：https://github.com/medcl/elasticsearch-analysis-ik

将安装包上传到Linux服务器，然后把zip包放到elasticsearch/plugins目录下创建的目录analysis-ik,并解压

然后解压ik分词器，因为ik分词器是zip包，所以需要使用unzip命令解压，如下图：

unzip elasticsearch-analysis-ik-7.16.2.zip

3、拷贝词典

解压之后需要把ik的config目录中的所有内容复制到elasticsearch-7.16.2的config配置文件中：

 cp ./config/* /opt/elasticsearch-7.16.2/config

最后一定要重启 ElasticSearch！！！

分词器 - IK分词器使用

IK分词器有两种分词模式：ik_max_word 和 ik_smart模式。

1. ik_smart

这个分词模式的颗粒度比较粗，如下图：

2. ik_max_word

这个分词模式的颗粒度比较细，如下图：

查询文档

创建索引，添加映射，指定使用IK分词器

# 创建索引，添加映射，指定使用IK分词器
PUT person
{
  "mappings": {
    "properties": {
      "name": {
        "type": "keyword"
      },
      "address": {
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

添加数据

# 添加文档
PUT person/_doc/1
{
  "name": "李四",
  "address": "北京朝阳区"
}
PUT person/_doc/2
{
  "name": "张三",
  "address": "华为5G手机"
}
PUT person/_doc/3
{
  "name": "麻子",
  "address": "北京海淀区"
}
PUT person/_doc/4
{
  "name": "王五",
  "address": "上海昌平区"
}

词条查询（term）：词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才会搜索

全文查询（match）：全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

ElasticSearch JavaAPI

SpringBoot整合ElasticSearch

引入依赖

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

配置客户端

@Configuration
public class ElasticSearchConfig extends AbstractElasticsearchConfiguration {
    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {
        final ClientConfiguration clientConfiguration =
                ClientConfiguration.builder()
                .connectedTo("192.168.139.130:9200")    // ElasticSearch服务的ip端口号
                .build();

        return RestClients.create(clientConfiguration).rest();
    }
}

配置完这些后，就已经向spring容器中注入一个RestHighLevelClient的bean对象，后面我们可以通过该对象操作ES

Java API - 操作索引

首先在测试类中注入elasticsearchClient这个bean

@SpringBootTest
class SpringbootElasticsearchApplicationTests {

    @Autowired
    private RestHighLevelClient elasticsearchClient;

}

添加索引

创建索引：

/**
 * 添加索引
 */
@Test
public void addIndex() throws IOException {
    // 1、通过elasticsearchClient获取操作索引的对象
    IndicesClient indices = elasticsearchClient.indices();
    // 2、具体操作，获取返回值
    CreateIndexRequest createRequest = new CreateIndexRequest("index1");
    CreateIndexResponse createIndexResponse = indices.create(createRequest, RequestOptions.DEFAULT);
    // 3、根据返回值判断结果
    System.out.println(createIndexResponse.isAcknowledged());
}

我们到界面查询一下

创建索引的同时设置映射信息：

/**
 * 添加索引的同时 添加映射
 */
@Test
public void addIndexAndMapping() throws IOException {
    // 1、通过elasticsearchClient获取操作索引的对象
    IndicesClient indices = elasticsearchClient.indices();
    // 2、具体操作，获取返回值
    CreateIndexRequest createRequest = new CreateIndexRequest("index2");
    // 映射json字符串， 跟在Kibana 语法格式一致， 因此可以现在Kibana上写好 再粘贴过来
    String mapping = " {\n" +
            "    \"properties\": {\n" +
            "      \"name\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"address\": {\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      }\n" +
            "    }\n" +
            "  }";
    createRequest.mapping(mapping, XContentType.JSON);
    CreateIndexResponse createIndexResponse = indices.create(createRequest, RequestOptions.DEFAULT);
    // 3、根据返回值判断结果
    System.out.println(createIndexResponse.isAcknowledged());
}

界面查询

查询索引

/**
 * 查询索引
 */
@Test
public void queryIndex() throws IOException {
    // 1、通过elasticsearchClient获取操作索引的对象
    IndicesClient indices = elasticsearchClient.indices();

    GetIndexRequest getRequest = new GetIndexRequest("index1");
    GetIndexResponse response = indices.get(getRequest, RequestOptions.DEFAULT);

    // 这里我们获取该索引对应的映射
    Map<String, MappingMetadata> mappings = response.getMappings();

}

删除索引

/**
 * 删除索引
 */
@Test
public void deleteIndex() throws IOException {
    // 1、通过elasticsearchClient获取操作索引的对象
    IndicesClient indices = elasticsearchClient.indices();

    DeleteIndexRequest deleteRequest = new DeleteIndexRequest("index1");
    AcknowledgedResponse Response = indices.delete(deleteRequest, RequestOptions.DEFAULT);

    System.out.println(Response.isAcknowledged());

}

判断索引是否存在

/**
 * 判断索引是否存在
 */
@Test
public void existIndex() throws IOException {
    // 1、通过elasticsearchClient获取操作索引的对象
    IndicesClient indices = elasticsearchClient.indices();

    GetIndexRequest getRequest = new GetIndexRequest("index1");
    boolean exists = indices.exists(getRequest, RequestOptions.DEFAULT);

    System.out.println(exists);

}

操作文档

添加文档

添加map数据

/**
 * 添加文档 - map类型数据
 */
@Test
public void addDoc() throws IOException {
    // 数据对象 map
    HashMap<String, Object> data = new HashMap<>();
    data.put("name", "李星云");
    data.put("address", "苗疆");

    // 1、 获取操作文档的对象
    IndexRequest request = new IndexRequest("person")  // 指定添加在哪个索引中
            .id("8")    // 指定id
            .source(data);
    // 添加数据，获取结果
    IndexResponse response = elasticsearchClient.index(request, RequestOptions.DEFAULT);
    // 打印响应结果
    System.out.println(response.getId());
}

添加json数据

/**
 * 添加文档 - json字符串类型数据
 */
@Test
public void addDoc2() throws IOException {
    // 数据对象 json字符串
    Person person = new Person();
    person.setName("袁天罡");
    person.setAddress("不良人，藏兵谷");
    // Javabean -> json字符串
    String data = JSON.toJSONString(person);

    // 1、 获取操作文档的对象
    IndexRequest request = new IndexRequest("person")  // 指定添加在哪个索引中
            .id("9")    // 指定id
            .source(data, XContentType.JSON);
    // 添加数据，获取结果
    IndexResponse response = elasticsearchClient.index(request, RequestOptions.DEFAULT);
    // 打印响应结果
    System.out.println(response.getId());
}

修改文档

修改文档： 添加文档时，若id存在则修改，id不存在则添加（这里就不做演示了）

查询文档

/**
 * 根据id查询文档
 */
@Test
public void findDocById() throws IOException {
    GetRequest getRequest = new GetRequest("person", "9");  // 获取person索引库下 id为9的文档
    GetResponse response = elasticsearchClient.get(getRequest, RequestOptions.DEFAULT);
    System.out.println(response.getSourceAsString());   // getSourceAsString(): 获取数据对应的json
}

删除文档

/**
 * 根据id删除文档
 */
@Test
public void deleteDocById() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("person", "9");  // 获取person索引库下 id为9的文档
    DeleteResponse response = elasticsearchClient.delete(deleteRequest, RequestOptions.DEFAULT);
    System.out.println(response.getId()); 
}

ElasticSearch高级操作

批量操作

Bulk批量操作是将文档的增删改查一系列操作，通过一次请求全都做完。减少网络传输的次数。

批量操作 - 脚本

示例：

# 批量操作
# 1. 删除5号记录
# 2. 添加8号记录
# 3. 修改2号记录 名称为“二号”

POST _bulk
{"delete": {"_index":"person", "_id":"5"}}
{"create": {"_index":"person", "_id":"8"}}
{"name":"上官婉儿", "address":"大唐王朝"}
{"update": {"_index":"person", "_id":"2"}}
{"doc":{"name":"二号"}}

批量操作 - JavaAPI

/**
 * 批量操作 bulk
 */
@Test
public void testBulk() throws IOException {

    // 一、创建bulkrequest对象，整合所有操作
    BulkRequest bulkRequest = new BulkRequest();

    /*
    # 1、删除2号记录
    # 2、添加6号记录
    # 3、修改8号记录， 名称为"三号"
    */
    // 1、删除2号记录
    DeleteRequest deleteRequest = new DeleteRequest("person", "2");
    // 2、添加6号记录
    HashMap<String, Object> map1 = new HashMap<>(); map1.put("六号","华夏");
    IndexRequest indexRequest = new IndexRequest("person").id("6").source(map1);
    // 3、修改8号记录， 名称为"八号"
    HashMap<String, Object> map2 = new HashMap<>(); map2.put("name","八号");
    UpdateRequest updateRequest = new UpdateRequest("person", "8").doc(map2);

    // 二、把上面三个请求 添加到bulkRequest对象中
    bulkRequest.add(deleteRequest);
    bulkRequest.add(indexRequest);
    bulkRequest.add(updateRequest);

    // 三、通过elast客户端发送请求icsearchClient
    elasticsearchClient.bulk(bulkRequest, RequestOptions.DEFAULT);
}

查看结果：

导入数据

目标： 将mysql中goods表中的数据导入到ES中

goods表结构：

表数据：

根据表结构在ES中创建对应索引：

PUT goods
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "price": {
        "type": "double"
      },
      "createTime": {
        "type": "date"
      },
      "categoryName": {
        "type": "keyword"
      },
      "brandName": {
        "type": "keyword"
      },
      "spec": {
        "type": "object"
      },
      "saleNum": {
        "type": "integer"
      },
      "stock": {
        "type": "integer"
      }
    }
  }
}

创建对应的domain类：

public class Goods {
    private int id;
    private String title;
    private double price;
    private int stock;
    private int saleNum;
    private Date createTime;
    private String categoryName;
    private String brandName;
    private Map spec;

    @JSONField(serialize = false)   // 使用fastjosn在转换json时 ，会忽略该字段
    private String specStr;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    public int getSaleNum() {
        return saleNum;
    }

    public void setSaleNum(int saleNum) {
        this.saleNum = saleNum;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getCategoryName() {
        return categoryName;
    }

    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public Map getSpec() {
        return spec;
    }

    public void setSpec(Map spec) {
        this.spec = spec;
    }

    public String getSpecStr() {
        return specStr;
    }

    public void setSpecStr(String specStr) {
        this.specStr = specStr;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", price=" + price +
                ", stock=" + stock +
                ", saleNum=" + saleNum +
                ", createTime=" + createTime +
                ", categoryName='" + categoryName + '\'' +
                ", brandName='" + brandName + '\'' +
                ", spec=" + spec +
                ", specStr='" + specStr + '\'' +
                '}';
    }
}

查询Goods表数据，并导入：

@Autowired
private GoodsMapper goodsMapper;
@Autowired
private RestHighLevelClient elasticsearchClient;

@Test
public void importData() throws IOException {
    // 1、 查询所有数据
    List<Goods> goods = goodsMapper.findAll();

    // 2、bulk导入
    BulkRequest bulkRequest = new BulkRequest();

    // 2.1 循环goods ,创建IndexRequest添加数据
    for (Goods item: goods) {
        // 2.2 将 sepc 这属性导入进去
        item.setSpec(JSON.parseObject(item.getSpecStr(), Map.class));

        IndexRequest indexRequest = new IndexRequest("goods");
        // 2.3 将good对象导入到es
        indexRequest
                .id(item.getId()+"")    // 指定id
                .source(JSON.toJSONString(item), XContentType.JSON);    // 将对象转成json字符串
        bulkRequest.add(indexRequest);
    }



    elasticsearchClient.bulk(bulkRequest, RequestOptions.DEFAULT);
}

数据库操作这一块儿，我使用的是mybatis，这里就详细介绍了

执行测试方法之后，查看ES库：

各种查询

matchAll 查询

matchAll 查询 - 脚本：

matchAll查询：查询所有文档

语法

GET 索引名称/_search
{
  "query": {
    "match_all": {}
  }
}

默认情况下，es一次展示10条数据

可以通过from和size来控制分页

GET goods/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 2
}

咱们来分析一下结果：

matchAll 查询 - JavaAPI：

   /**
     * 查询所有
     * 1. matchAll
     * 2. 将查询结果封装为Goods对象，装载到List中
     * 3. 分页操作。 默认显示10条
     */
    @Test
    public void matchAll() throws IOException {

        // 2. 构建查询search请求对象。指定查询的索引名称
        SearchRequest searchRequest = new SearchRequest("goods");
        // 4. 创建查询条件构造器 searchBuilder
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 6. 查询条件
        MatchAllQueryBuilder query = QueryBuilders.matchAllQuery(); // 查询所有文档
        // 5. 指定查询条件
        sourceBuilder.query(query);
        // 8. 添加分页信息
        sourceBuilder.from(0);
        sourceBuilder.size(8);
        // 3. 添加查询条件构建器对象
        searchRequest.source(sourceBuilder);

        // 1. 查询
        SearchResponse searchResponse = elasticsearchClient.search(searchRequest, RequestOptions.DEFAULT);


        // 7.获取命中对象 SearchHits
        SearchHits searchHits = searchResponse.getHits();
        // 7.1 获取总记录数
        long total = searchHits.getTotalHits().value;

        // 7.2 获取Hits数据 数组
        SearchHit[] hits = searchHits.getHits();

        List<Goods> goodsList = new ArrayList<>();
        for (SearchHit hit: hits) {
            // 获取json字符串格式的数据
            String jsonStr = hit.getSourceAsString();
            Goods goods = JSON.parseObject(jsonStr, Goods.class);
            goodsList.add(goods);
        }

        for (Goods good: goodsList) {
            System.out.println(good);
        }
    }

查询结果：

term 查询

term 查询 - 脚本：

term查询： 不会对查询条件再拆分

# term查询
GET 索引名称/_search
{
  "query": {
    "term": {
      "字段名称": {
        "value": "查询条件"
      }
    }
  }
}

其实我们的数据是一条记录是包含 “华为手机”的， 那么为什么刚刚没有匹配到任何结果呢？
让我们对该数据用分词器进行分词看看结果：

我们会发现，分词库中 不包含 完整的 “华为手机”分词，因此我们上面没有查询到结果。
接下来我们查询“华为”：

term 查询 - JavaAPI：

@Test
public void testTermQuery() throws IOException {
    SearchRequest searchrequest = new SearchRequest("goods");

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // match查询
    QueryBuilder query = QueryBuilders.termQuery("title","华为"); // term词条查询
    sourceBuilder.query(query);
    searchrequest.source(sourceBuilder);

    SearchResponse searchResponse = elasticsearchClient.search(searchrequest, RequestOptions.DEFAULT);
    SearchHits searchHits = searchResponse.getHits();
    // 获取记录数
    SearchHit[] hits = searchHits.getHits();
    List<Goods> goodsList = new ArrayList<>();
    for (SearchHit hit: hits) {
        // 获取json字符串格式的数据
        String jsonStr = hit.getSourceAsString();
        Goods goods = JSON.parseObject(jsonStr, Goods.class);
        goodsList.add(goods);
    }

    for (Goods good: goodsList) {
        System.out.println(good);
    }

}

查询结果：

match 查询

match查询 - 脚本：

match查询：

• 会对查询条件进行分词
• 然后将分词后的查询条件和词条进行等值匹配
• 默认取并集（OR）

语法1：

GET 索引名称/_search
{
  "query": {
    "match": {
      "查询字段": "查询条件"
    }
  }
}

语法2：

GET 索引名称/_search
{
  "query": {
    "match": {
      "查询字段": {
        "query": "查询条件",
        "operator": "操作（or 或者 and），即 并集 获取 交集"
      }
    }
  }
}

match查询 - JavaAPI：

@Test
public void testmatchQuery() throws IOException {
    SearchRequest searchrequest = new SearchRequest("goods");

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // match查询
    MatchQueryBuilder query = QueryBuilders.matchQuery("title", "华为手机");
    query.operator(Operator.AND);   // 求并集
    sourceBuilder.query(query);
    searchrequest.source(sourceBuilder);

    SearchResponse searchResponse = elasticsearchClient.search(searchrequest, RequestOptions.DEFAULT);
    SearchHits searchHits = searchResponse.getHits();
    // 获取记录数
    SearchHit[] hits = searchHits.getHits();
    List<Goods> goodsList = new ArrayList<>();
    for (SearchHit hit: hits) {
        // 获取json字符串格式的数据
        String jsonStr = hit.getSourceAsString();
        Goods goods = JSON.parseObject(jsonStr, Goods.class);
        goodsList.add(goods);
    }

    for (Goods good: goodsList) {
        System.out.println(good);
    }

}

查询结果：

模糊查询

模糊查询 - 脚本：

• wildcard查询：会对查询条件进行分词。还可以使用通配符？ （任意单个字符） 和 * （0个或多个字符）
• regexp查询：正则查询
• prefix：前缀查询

wildcard查询：

*：表示匹配多个
？：表示匹配一个

regexp查询（正则）：

前缀查询：

模糊查询 - JavaAPI：

wildcard查询：

@Test
public void testWildcardQuery() throws IOException {
    SearchRequest searchrequest = new SearchRequest("goods");

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // wildcard查询
    WildcardQueryBuilder query = QueryBuilders.wildcardQuery("title", "华*");
    sourceBuilder.query(query);
    searchrequest.source(sourceBuilder);

    SearchResponse searchResponse = elasticsearchClient.search(searchrequest, RequestOptions.DEFAULT);
    SearchHits searchHits = searchResponse.getHits();
    // 获取记录数
    SearchHit[] hits = searchHits.getHits();
    List<Goods> goodsList = new ArrayList<>();
    for (SearchHit hit: hits) {
        // 获取json字符串格式的数据
        String jsonStr = hit.getSourceAsString();
        Goods goods = JSON.parseObject(jsonStr, Goods.class);
        goodsList.add(goods);
    }

    for (Goods good: goodsList) {
        System.out.println(good);
    }

}

查询结果：

其他两种模糊查询就不演示了，改一下查询类型即可

范围查询

范围查询 - 脚本：

# 范围查询
GET 索引/_search
{
  "query": {
    "range": {
      "查询字段": {
        "gte": 最低值,
        "lte": 最高值
      }
    }
  }
}

其实上面查询的结果乱序的，那我们如何升序呢？
在查询结果的后面增加

  "sort": [
    {
      "排序字段": {
        "order": "desc 或者 asc"
      }
    }
  ]

例如：查询 price为 [34,45] 范围内的所有数据 ，按照降序排序：

# 范围查询
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 34,
        "lte": 45
      }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

其实所有的查询都可以排序，并非专属于范围查询

范围查询 - JavaAPI：

@Test
public void testRangeQuery() throws IOException {
    SearchRequest searchrequest = new SearchRequest("goods");

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 范围查询
    RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
    // 指定下限
    query.gte(34);
    // 指定上限
    query.lte(45);
    sourceBuilder.query(query);
    // 排序,DESC：降序
    sourceBuilder.sort("price", SortOrder.DESC);

    searchrequest.source(sourceBuilder);

    SearchResponse searchResponse = elasticsearchClient.search(searchrequest, RequestOptions.DEFAULT);
    SearchHits searchHits = searchResponse.getHits();
    // 获取记录数
    SearchHit[] hits = searchHits.getHits();
    List<Goods> goodsList = new ArrayList<>();
    for (SearchHit hit: hits) {
        // 获取json字符串格式的数据
        String jsonStr = hit.getSourceAsString();
        Goods goods = JSON.parseObject(jsonStr, Goods.class);
        goodsList.add(goods);
    }

    for (Goods good: goodsList) {
        System.out.println(good);
    }

}

查询结果：

queryString 查询

queryString：

• 会对查询条件进行分词
• 然后将分词后的查询条件和词条进行等值匹配
• 默认取并集（OR）
• 可以指定多个查询字段

queryString查询 - 脚本：

# queryString查询
GET 索引名称/_search
{
  "query": {
    "query_string": {
      "fields": [字段1,字段2,字段3], 
      "query": "查询的条件（可以 使用 OR 或者 AND 字段来求并集或交集）"
    }
  }
}

queryString查询 - JavaAPI：

@Test
public void testQueryStringQuery() throws IOException {
    SearchRequest searchrequest = new SearchRequest("goods");

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // queryString查询
    QueryStringQueryBuilder query = QueryBuilders
            .queryStringQuery("三星手机")   // 查询的条件
            // 要查询的几个字段
            .field("title")
            .field("categoryName")
            .field("brandName")
            .defaultOperator(Operator.AND); // 交集

    sourceBuilder.query(query);
    searchrequest.source(sourceBuilder);

    SearchResponse searchResponse = elasticsearchClient.search(searchrequest, RequestOptions.DEFAULT);
    SearchHits searchHits = searchResponse.getHits();
    // 获取记录数
    SearchHit[] hits = searchHits.getHits();
    List<Goods> goodsList = new ArrayList<>();
    for (SearchHit hit: hits) {
        // 获取json字符串格式的数据
        String jsonStr = hit.getSourceAsString();
        Goods goods = JSON.parseObject(jsonStr, Goods.class);
        goodsList.add(goods);
    }

    for (Goods good: goodsList) {
        System.out.println(good);
    }

}

查询结果：

布尔查询

如果我们查询的时候，一次有多个查询条件的话，那么我们可以使用布尔查询。例如京东商城如下界面：

boolQuery:布尔查询，可以对多个查询条件进行连接。

• must(and):条件必须成立
• must_not(not):条件必须不成立
• should(or):条件可以成立
• filter:条件必须成立，性能比must高。不会计算得分

脚本语法：

GET 索引名称/_search
{
    "query": {
        "bool": {
            "must": [{},{}...],
            "filter": [{},{}...],
            "must_not": [{},{}...],
            "should": [{},{}...]
        }
    }
}

脚本案例：

# boolquery 布尔查询
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": "三星"
          }
        }
      ],
      "filter": [
        {
          "term": {
            "title": "手机"
          }
        }
      ]
    }
  }
}

查询结果：

聚合查询

• 指标聚合： 相当于MySQL的聚合函数，max、min、avg、sum等

脚本案例：

# 指标聚合 聚合函数
GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "aggs": {
    "max_price": {
      "max": {
        "field": "price"
      }
    }
  }
}

• 桶聚合：相当于MySQL的group by 操作。 不要对text类型的数据进行分组，会失败

脚本案例：

# 桶聚合  分组
GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "aggs": {
    "goods_brands": {
      "terms": {
        "field": "brandName",
        "size": 10
      }
    }
  }
}

高亮查询

高亮三要素：

• 高亮字段
• 前缀
• 后缀

脚本案例：

# 高亮查询
GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "highlight": {
    "fields": {
      "title": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>"
      }
    }
  }
}

查询结果：