ES的介绍和使用

全文搜索引擎 Elastic Search

第一节引言

当系统数据量上了10亿、100亿条的时候，我们用什么数据库好？如何解决单点故障？如何提升检索速度？如何解决统计分析问题？

传统数据库的应对解决方案

关系型数据库

通过主从备份解决数据安全性问题；
通过数据库代理中间件心跳监测，解决单点故障问题；
通过代理中间件将查询语句分发到各个slave节点进行查询，并汇总结果

非关系型数据库

通过副本备份保证数据安全性；
通过节点竞选机制解决单点问题；
先从配置库检索分片信息，然后将请求分发到各个节点，最后由路由节点合并汇总结果

另辟蹊径

存储数据时按有序存储；
将数据和索引分离；
压缩数据;

于是，Elastic Search就在这种背景下诞生了

第二节 Elastic Search 介绍

1.1 ES简介

Elastic Search 简称ES，是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。

1.2 `ES` 与 `Lucene` 的关系

Lucene 只是一个库。想要使用它，你必须使用Java来作为开发语言并将其直接集成到你的应用中，更糟糕的是，Lucene 非常复杂，你需要深入了解检索的相关知识来理解它是如何工作的
ES也使用Java开发并使用 Lucene 作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的 RESTful API来隐藏 Lucene 的复杂性，从而让全文搜索变得简单

第二节安装 Elastic Search

2.1 安装 Elastic Search

解压 elasticsearch-7.6.2-windows-x86_64.zip

2.2 安装 `Kibana`

解压 kibana-7.6.2-windows-x86_64.zip

修改配置

elasticsearch.hosts: ["http://localhost:9200"]

2.3 安装 `IK Analyzer`

进入 elasticsearch-7.6.2\plugins 目录
创建文件夹 ik
将 elasticsearch-analysis-ik-7.6.2.zip 拷贝至 ik 目录下，然后解压

ELK = Elasticsearch Logstash Kibana => 日志采集系统

第三节 ES 结构

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

结构说明：

ES中的索引（index）相当于 MySQL 中的数据库(database)，但ES7之后建议每个索引下只存放一种类型(type)
ES中的数据分片(shard)是特有的，在集群模式下，海量的数据可以分别存储在不同的分片中，每个分片都有备份数据，其备份数据称为replica，备份数据的主要作用就是在主分片数据不可用的情况下，会将备份数据(replica)作为新的主分片使用
ES中的类型(type)相当于 MySQL 中的表(table)
ES中的文档(document)相当于 MySQL 中的表的一行数据(row)
ES中的字段(field)相当于 MySQL 中的表的字段(field)

第四节 ES 字段类型

4. 1 字符串类型

text：一般被用于全文检索。将当前Field进行分词。
keyword：当前Field不会被分词。

4.2 数值类型

long：占用8个字节
integer：占用4个字节
short：占用2个字节
byte：占用1个字节
double：占用8个字节
float：占用4个字节

4.3 范围类型

long_range：赋值时，无需指定具体的内容，只需要存储一个范围即可，指定gt，lt，gte，lte
integer_range：同上
double_range：同上
float_range：同上
date_range：同上
ip_range：同上

4.4 其他类型

date类型，针对时间类型指定具体的格式
boolean类型，表达true和false
binary类型暂时支持Base64 encode string
经纬度类型：geo_point：用来存储经纬度的
ip类型：ip：可以存储IPV4或者IPV6

第五节 ES `RESTful` 操作

5.1 索引操作

5.1.1 创建索引

# 创建索引  请求方式只能是PUT   /user表示创建一个user索引
# settings表示这个索引的一些设置  number_of_shards表示分片数量
# number_of_replicas 表示每个分片的副本数量
PUT /user
{"settings": {"number_of_shards": 3,"number_of_replicas": 1}
}

结果：

# acknowledged表示索引创建的回执信息，也就是响应的结果
# shards_acknowledged表示索引分片创建的回执信息
# index表示索引的名称
{"acknowledged" : true, "shards_acknowledged" : true,"index" : "user"
}

5.1.2 查看索引

GET /user

结果：

# user表示索引名称
# aliases表示索引的别名
# mappings表示索引中的字段
# settings表示索引的创建信息
{"user" : {"aliases" : { },"mappings" : { },"settings" : {"index" : {"creation_date" : "1667629798434","number_of_shards" : "3","number_of_replicas" : "1","uuid" : "VwShKX6-TliIeCIKttsRwA","version" : {"created" : "7060299"},"provided_name" : "user"}}}
}

5.1.3 删除索引

DELETE /user

结果：

{"acknowledged" : true
}

5.2 类型操作

5.2.1 创建类型

# /user/_mappings表示设置user索引的具体数据结构，相当于定义类中的属性
# class User{ String name; String sex; int age; Date birthday;}
PUT /user/_mappings
{"properties": {"name": {"type": "text","analyzer": "ik_max_word","index": true,"store": false},"sex": {"type": "keyword"},"age": {"type": "integer"},"birthday": {"type": "date","format": "yyyy-MM-dd"}}
}

结果：

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

5.2.2 查看类型

GET /user

结果：

{"user" : {"aliases" : { },"mappings" : {"properties" : {"age" : {"type" : "integer"},"birthday" : {"type" : "date","format" : "yyyy-MM-dd"},"name" : {"type" : "text","analyzer" : "ik_max_word"},"sex" : {"type" : "keyword"}}},"settings" : {"index" : {"creation_date" : "1667631425739","number_of_shards" : "5","number_of_replicas" : "1","uuid" : "hfhUHBKWQZukfeZLlteHKQ","version" : {"created" : "7060299"},"provided_name" : "user"}}}
}

5.3 文档操作

5.3.1 增加文档

POST /user/_doc
{"name": "张三","sex": "男","age": 20,"birthday": "2000-05-06"
}

结果：

{"_index" : "user","_type" : "_doc","_id" : "lfKkRoQB18W7DskkwOaq","_version" : 1,"result" : "created","_shards" : {"total" : 2,"successful" : 1,"failed" : 0},"_seq_no" : 0,"_primary_term" : 1
}

5.3.2 查看文档

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

结果：

{"took" : 1,"timed_out" : false,"_shards" : {"total" : 5,"successful" : 5,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 1.0,"hits" : [{"_index" : "user","_type" : "_doc","_id" : "lfKkRoQB18W7DskkwOaq","_score" : 1.0,"_source" : {"name" : "张三","sex" : "男","age" : 20,"birthday" : "2000-05-06"}}]}
}

5.3.3 修改文档

# 修改语法： /索引/_doc/数据ID
# 这种修改需要注意，不是只修改一个属性，而是对整个文档进行修改，可以理解为是用一个新的文档去替换原来的文档完成修改。如果新的文档
# 只有1个属性，那么替换后的文档也只有1个属性。
PUT /user/_doc/lfKkRoQB18W7DskkwOaq
{"sex": "女"
}

结果：

{"_index" : "user","_type" : "_doc","_id" : "lfKkRoQB18W7DskkwOaq","_version" : 3,"result" : "updated","_shards" : {"total" : 2,"successful" : 1,"failed" : 0},"_seq_no" : 2,"_primary_term" : 1
}

5.3.4 删除文档

DELETE /user/_doc/lfKkRoQB18W7DskkwOaq

结果：

{"_index" : "user","_type" : "_doc","_id" : "lfKkRoQB18W7DskkwOaq","_version" : 4,"result" : "deleted","_shards" : {"total" : 2,"successful" : 1,"failed" : 0},"_seq_no" : 3,"_primary_term" : 1
}

第六节 Java 操作 ES

6.1 创建maven工程

<parent><artifactId>spring-boot-starter-parent</artifactId><groupId>org.springframework.boot</groupId><version>2.3.2.RELEASE</version>
</parent>
<groupId>com.qf</groupId>
<artifactId>es</artifactId>
<version>1.0</version><properties><maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!--spring-data提供的操作elasticsearch的包--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>
</dependencies>

6.2 编写实体类

@Data
//Document表示文档，文档的类型就是Article，文档中的字段就是Article中定义的字段
//indexName表示这个文档所在的索引，shards表示分片数量，replicas表示副本的数量
@Document(indexName = "article", shards = 10, replicas = 2)
public class Article {//Id表示这个字段就是确定这条数据的@Id//Field表示字段的定义，name表示在文档中存储的名字，type表示字段类型@Field(name = "id", type = FieldType.Long)private Long id;//Field表示字段的定义，analyzer表示存储时使用的分词器，searchAnalyzer表示查询时使用的分词器@Field(name = "title", type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")private String title;//Field表示字段的定义，FieldType.Keyword表示这个字段就是个关键词，不需要再分词，//index表示是否建立索引，默认为true，不需要建立索引时需要显示指定@Field(name = "content", type = FieldType.Keyword, index = false)private String content;@Field(name = "author", type = FieldType.Text)private String author;@Field(name = "author_name", type = FieldType.Text)private String authorName;//日期格式网址说明// https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html@Field(name = "publish_date", type = FieldType.Date, format = DateFormat.year_month_day)private Date publishDate;@Field(name = "category", type=FieldType.Text)private String category;@Field(name = "publishType", type = FieldType.Text)private String publishType; //发布形式：全部可见，部门可见@Field(name = "level", type = FieldType.Text)private String level; //文章等级： 初级、中级、高级
}

6.3 索引操作

6.3.1 编写测试类

@SpringBootTest
class IndexTest {@Autowiredprivate ElasticsearchRestTemplate restTemplate;
}

6.3.2 创建索引

@Test
public void createIndex(){//获取一个索引操作对象，如果索引不存在，则直接创建IndexOperations indexOperations = restTemplate.indexOps(Article.class);System.out.println(indexOperations);
}

6.3.3 删除索引

@Test
public void deleteIndex(){//获取一个索引操作对象IndexOperations indexOperations = restTemplate.indexOps(Article.class);indexOperations.delete();
}

6.4 文档操作

6.4.1 编写Repository

//ElasticsearchRepository  继承所有父接口的特性
//PagingAndSortingRepository 分页操作
//CrudRepository 基本的CRUD操作
@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article, Long> {
}

6.4.2 编写测试类

@SpringBootTest
class DocumentTest {@Autowiredprivate ArticleRepository articleRepository;
}

6.4.3 添加文档

@Test
public void addArticle(){Article article = new Article();article.setId(1L);article.setAuthor("admin");article.setContent("这是一篇很有意思的文章");article.setCreatedDate(new Date());article.setTitle("Java是一门很简单的语言");articleRepository.save(article);
}

6.4.4 修改文档

@Test
public void updateArticle(){Article article = new Article();article.setId(1L);article.setAuthor("admin");article.setContent("这是一篇很有意思的文章");article.setCreatedDate(new Date());article.setTitle("Java很牛逼");articleRepository.save(article);
}

6.4.5 查询文档

@Test
public void searchArticle(){Optional<Article> opt = articleRepository.findById(1L);Article article = opt.orElse(null);System.out.println(article);
}

6.4.6 删除文档

@Test
public void deleteArticle(){articleRepository.deleteById(1L);
}

6.4.7 批量保存

@Test
public void batchAddArticle(){List<Article> articles = new ArrayList<>();for(int i=0; i<100; i++){Article article = new Article();article.setId((long) (i+2));article.setAuthor("author"+i);article.setContent("这是一篇很有意思的文章" + i);article.setCreatedDate(new Date());article.setTitle("Java很牛逼" + i);articles.add(article);}articleRepository.saveAll(articles);
}

6.4.8 分页查询

@Test
public void pageSearch(){//查询构建器，这里用的匹配所有的查询构建器QueryBuilder builder = new MatchAllQueryBuilder();//分页对象Pageable pageable = PageRequest.of(1, 20);//分页查询Page<Article> articlePage = articleRepository.search(builder, pageable);//获取总条数long total = articlePage.getTotalElements();System.out.println("总条数：" + total);//获取查询结果List<Article> articleList = articlePage.getContent();articleList.forEach(System.out::println);
}

6.4.9 排序查询

@Test
public void sortSearch(){Sort.Order dateOrder = Sort.Order.desc("createdDate"); //日期降序排列Sort.Order idOrder = Sort.Order.asc("id");//ID升序排列Iterable<Article> articles = articleRepository.findAll(Sort.by(dateOrder, idOrder));articles.forEach(System.out::println);
}

6.4.10 自定义查询

自定义查询的命名规则：方法名必须是get、find、read、query其中之一开始，后面接字段名以及条件，条件之间的组合使用and或者or，方法参数必须与使用的字段一一匹配

@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article, Long> {//文章标题模糊查询，并且ID在给定的范围之内List<Article> getByTitleLikeAndIdBetween(String title, Long min, Long max);
}

测试：

@Test
public void customerQuery(){Calendar c = Calendar.getInstance();c.roll(Calendar.DAY_OF_MONTH, -1);List<Article> articles = articleRepository.getByTitleLikeAndIdBetween("Java", 20L, 30L);articles.forEach(System.out::println);
}

6.5 ES查询操作[重点]

新建一个测试类

@SpringBootTest
class QueryTest {@Autowiredprivate RestHighLevelClient client;
}

6.5.1 term 查询

term的查询是代表完全匹配，这里的完全匹配指的是，查询的内容不会被分词，而是作为一个整体到存储的数据中去匹配，如果数据对应的字段有进行分词，那么只要其中任何一个分词结果与查询内同匹配，那么该数据将在查询结果中展示

查询语法：

# from表示开始的位置，size表示最大查询的条数， query表示查询的条件，term表示这里使用的是精确查找
# 精确查找的条件就是id字段的值为2， term中只能有一个字段作为条件
GET /article/_search
{"from": 0,"size": 20,"query": {"term": {"id": {"value": 2}}}
}

测试：

@Test
public void termQueryTest() throws IOException {//查询资源构建器SearchSourceBuilder builder = new SearchSourceBuilder();builder.from(0).size(20); //相当于 LIMIT 0, 20//term查询 = 精确查询builder.query(QueryBuilders.termQuery("id", 2L));//创建查询请求SearchRequest request = new SearchRequest("article");//将查询构建器放入请求中request.source(builder);//查询并得到结果SearchResponse response = client.search(request, RequestOptions.DEFAULT);//从结果中获取查询命中信息SearchHits searchHits = response.getHits();//获取总命中数long totalHits = searchHits.getTotalHits();System.out.println("查询命中条数：" + totalHits);//获取所有的命中数据SearchHit[] hits = searchHits.getHits();//获取每一条被命中的信息for(SearchHit hit: hits){//将命中的数据转换为一个mapMap<String, Object> rowData = hit.getSourceAsMap();System.out.println(rowData);}client.close();
}

6.5.2 terms 查询

terms查询与term查询的原理是一样的，只是terms查询针对的是一个字段可能对应多个值的情况，相当于 MySQL 中的条件in

# 查询id在2,3,4,5中的数据
POST /article/_search
{"from": 0,"size": 20,"query": {"terms": {"id": [2, 3, 4, 5]}}
}

测试：

@Test
public void termsQueryTest() throws IOException {//查询资源构建器SearchSourceBuilder builder = new SearchSourceBuilder();builder.from(0).size(20); //相当于 LIMIT 0, 20//terms查询 = 相当于MySQL中的INbuilder.query(QueryBuilders.termsQuery("id", Arrays.asList(2,3,4,5)));//创建查询请求SearchRequest request = new SearchRequest("article");//将查询构建器放入请求中request.source(builder);//查询并得到结果SearchResponse response = client.search(request, RequestOptions.DEFAULT);//从结果中获取查询命中信息SearchHits searchHits = response.getHits();//获取总命中数long totalHits = searchHits.getTotalHits();System.out.println("查询命中条数：" + totalHits);//获取所有的命中数据SearchHit[] hits = searchHits.getHits();//获取每一条被命中的信息for(SearchHit hit: hits){//将命中的数据转换为一个mapMap<String, Object> rowData = hit.getSourceAsMap();System.out.println(rowData);}client.close();
}

6.5.3 match查询[重点]

match查询属于高层查询，会根据查询的字段类型不一样，采用不同的查询方式。

查询的是日期或者是数值的话，会将你基于的字符串查询内容转换为日期或者数值对待。
如果查询的内容是一个不能被分词的内容（keyword），match查询不会对你指定的查询关键字进行分词。
如果查询的内容是一个可以被分词的内容（text），match会将你指定的查询内容根据一定的方式去分词，去分词库中匹配指定的内容。

match查询，实际底层就是多个term查询，将多个term查询的结果给你封装到了一起

6.5.3.1 查询日期

GET /article/_search
{"size": 500, "query": {"match": {"publish_date": "2022-11-07"}}
}

测试：

@Test
public void date_matchTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//这里的日期格式自动转换为日期匹配builder.query(QueryBuilders.matchQuery("publish_date","2022-11-07"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.3.2 查询内容分词

如果查询的字段使用了分词，那么查询的内容也将分词。只要数据匹配其中的一个分词内容即可。

GET /article/_search
{"size": 500, "query": {"match": {"title": "中国人民"}}
}

测试：

@Test
public void analyzer_matchTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//这里的title使用的查询内容是"中国人民"，这里会进行分词，分词之后再匹配builder.query(QueryBuilders.matchQuery("title","中国人民"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.3.2 查询内容不分词

如果查询的字段没有使用分词，那么查询的内容就不会分词。

GET /article/_search
{"size": 500, "query": {"match": {"author_name": "张三丰"}}
}

测试：

@Test
public void none_analyzer_matchTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//这里的author_name使用的查询内容是"张三丰"，这里会进行分词，分词之后再匹配builder.query(QueryBuilders.matchQuery("author_name","张三丰"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.3.3 布尔 match 查询

基于一个Field匹配的内容，采用and或者or的方式连接

# 这里的"中华共和"会被分词，分为"中华"和"共和"，这两个词用 and 衔接，表示要同时匹配上
GET /article/_search
{"size": 500, "query": {"match": {"title": {"query": "中华共和","operator": "and"}}}
}

测试：

@Test
public void bool_analyzer_matchTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//这里的title使用的查询内容是"中华共和"，这里会进行分词，分词之后的所有分词结果必须要全部匹配builder.query(QueryBuilders.matchQuery("title","中华共和").operator(Operator.AND));//默认衔接操作就是OR//        builder.query(QueryBuilders.matchQuery("title","中国人民").operator(Operator.OR));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.3.4 multi_match 查询

查询内容可以与多个字段匹配的就需要使用 multi_match查询

GET /article/_search
{"size": 500, "query": {"multi_match": {"query": "中国","fields": ["category", "title"]}}
}

测试：

@Test
public void multi_matchTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//这里的"中国"既可以与title匹配，也可以与category匹配，任意满足即可builder.query(QueryBuilders.multiMatchQuery("中国","title", "category"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.4 其他查询

6.5.4.1 prefix 查询

GET /article/_search
{"size": 500, "query": {"prefix": {"content": "测试1"}}
}

测试：

@Test
public void prefixQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//content字段内容以"测试1"开始builder.query(QueryBuilders.prefixQuery("content","测试1"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.4.2 fuzzy查询

在实际的搜索中，我们有时候会打错字，从而导致搜索不到。在 Elastic Search 中，我们可以使用 fuzziness 属性来进行模糊查询，从而达到搜索有错别字的情形。fuzziness 表示编辑距离，编辑距离是对两个字符串差异长度的量化，及一个字符至少需要处理多少次才能变成另一个字符，比如lucene和lucece只差了一个字符他们的编辑距离是1。编辑距离的值可以是0,1,2或者auto

GET /article/_search
{"size": 500, "query": {"fuzzy": {"title": {"value": "中华国","fuzziness": 2}}}
}

测试：

@Test
public void fuzzyQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//中华国变化两次可以与title的内容匹配builder.query(QueryBuilders.fuzzyQuery("title","中华国").fuzziness(Fuzziness.TWO));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.4.3 wildcard 查询

通配查询，和 MySQL 中的like是一个套路，可以在查询时，在字符串中指定通配符*和占位符？

GET /article/_search
{"size": 500, "query": {"wildcard": {"title": {"value": "中华*"}}}
}

测试：

@Test
public void wildcardQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//title的内容需要以中华开始builder.query(QueryBuilders.wildcardQuery("title","中华*"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.4.4 range查询

范围查询，只针对数值类型，对某一个Field进行大于或者小于的范围指定。需要注意的是，ES中的存储比较都是按照字符串顺序来的

GET /article/_search
{"size": 500, "query": {"range": {"id": {"gte": 100,"lte": 50}}}
}

测试：

@Test
public void rangeQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);//id的字符串顺序在100~50builder.query(QueryBuilders.rangeQuery("id").gte(100).lte(50));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.5 复合查询[重点]

6.5.5.1 bool 查询

复合过滤器，将多个查询条件，以一定的逻辑组合在一起。

must：所有的条件，用must组合在一起，表示And的意思
must_not：将must_not中的条件，全部都不能匹配，表示Not的意思
should：所有的条件，用should组合在一起，表示Or的意思

GET /article/_search
{"size": 500, "query": {"bool": {"should": [{"term": {"author_name": {"value": "张三"}}},{"term": {"category": {"value": "中国文化"}}}],"must_not": [{"match": {"category": "黄赌毒"}}],"must": [{"range": {"publish_date": {"gte": "2022-11-06","lte": "2022-11-08"}}}]}}
}

测试

@Test
public void boolQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();boolQueryBuilder.should(QueryBuilders.termQuery("author_name", "张三"));boolQueryBuilder.should(QueryBuilders.termQuery("category", "中国文化"));boolQueryBuilder.mustNot(QueryBuilders.matchQuery("category", "黄赌毒"));boolQueryBuilder.must(QueryBuilders.rangeQuery("publish_date").gte("2022-11-06").lte("2022-10-08"));builder.query(boolQueryBuilder);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}
}

6.5.5.2 boosting 查询

boosting查询可以帮助我们去影响查询后的score。

positive：只有匹配上positive的查询的内容，才会被放到返回的结果集中。
negative：如果匹配上和positive并且也匹配上了negative，就可以降低这样的文档score。
negative_boost：指定系数，必须小于1.0

关于查询时，分数是如何计算的：

搜索的关键字在文档中出现的频次越高，分数就越高
指定的文档内容越短，分数就越高
我们在搜索时，指定的关键字也会被分词，这个被分词的内容，被分词库匹配的个数越多，分数越高

GET /article/_search
{"size": 500, "query": {"boosting": {"positive": {"match": {"title": "中国共和"}},"negative": {"match": {"level": "高级"}},"negative_boost": 0.4}}
}

测试：

@Test
public void boostingQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);BoostingQueryBuilder boostingQueryBuilder = QueryBuilders.boostingQuery(QueryBuilders.matchQuery("title", "中华共和"),QueryBuilders.matchQuery("level", "高级")).negativeBoost(0.4f);builder.query(boostingQueryBuilder);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);SearchHits hits = resp.getHits();//4. 输出结果for (SearchHit hit : hits.getHits()) {float score = hit.getScore();Map<String, Object> map = hit.getSourceAsMap();System.out.println(map + " => " + score);}
}

6.5.6 filter 查询[重点]

query，根据你的查询条件，去计算文档的匹配度得到一个分数，并且根据分数进行排序，不会做缓存的。

filter，根据你的查询条件去查询文档，不去计算分数，而且filter会对经常被过滤的数据进行缓存。

GET /article/_search
{"size": 500, "query": {"bool": {"filter": [{"term": {"title": "中国"}},{"range": {"publish_date": {"gte": "2022-11-06","lte": "2022-11-08"}}}]}}
}

测试：

@Test
public void filterQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();boolQueryBuilder.filter(QueryBuilders.termQuery("title", "中国"));boolQueryBuilder.filter(QueryBuilders.rangeQuery("publish_date").gte("2022-11-06").lt("2022-11-08"));builder.query(boolQueryBuilder);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);SearchHits hits = resp.getHits();//4. 输出结果for (SearchHit hit : hits.getHits()) {float score = hit.getScore();Map<String, Object> map = hit.getSourceAsMap();System.out.println(map + " => " + score);}
}

6.5.7 高亮查询[重点]

高亮查询就是用户输入的关键字，以一定的特殊样式展示给用户，让用户知道为什么这个结果被检索出来。

高亮展示的数据，本身就是文档中的一个Field，单独将Field以highlight的形式返回给你。

ES提供了一个highlight属性，和query同级别的。

fragment_size：指定高亮数据展示多少个字符回来。
pre_tags：指定前缀标签，举个例子< font color=“red” >
post_tags：指定后缀标签，举个例子< /font >
fields：指定哪几个Field以高亮形式返回

GET /article/_search
{"size": 500, "query": {"bool": {"filter": [{"term": {"title": "中国"}},{"range": {"publish_date": {"gte": "2022-11-06","lte": "2022-11-08"}}}]}},"highlight": {"fields": {"title": {}}, "pre_tags": "<font color='red'>","post_tags": "</font>"}
}

测试：

@Test
public void highlightQueryTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(500);BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();boolQueryBuilder.filter(QueryBuilders.termQuery("title", "中国"));boolQueryBuilder.filter(QueryBuilders.rangeQuery("publish_date").gte("2022-11-06").lt("2022-11-08"));builder.query(boolQueryBuilder);HighlightBuilder highlightBuilder = new HighlightBuilder();highlightBuilder.field("title").preTags("<font color='red'>").postTags("</font>");builder.highlighter(highlightBuilder);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);SearchHits hits = resp.getHits();//4. 输出结果for (SearchHit hit : hits.getHits()) {HighlightField highlightField = hit.getHighlightFields().get("title");String fieldName = highlightField.getName();Text[] fragments = highlightField.getFragments();System.out.println(fieldName + " => "+ Arrays.stream(fragments).map(Text::string).collect(Collectors.joining(",")));}
}

6.5.8 聚合查询[重点]

ES的聚合查询和 MySQL 的聚合查询类似，ES的聚合查询相比 MySQL 要强大的多，ES提供的统计数据的方式多种多样。

# ES聚合查询的RESTful语法
POST /index/type/_search
{"aggs": {"名字（agg）": {"agg_type": {"属性": "值"}}}
}

6.5.8.1 去重计数查询

GET /article/_search
{"aggs": {"authorNameAgg": {"cardinality": {"field": "author_name"}}}
}

测试：

@Test
public void cardinalityTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.aggregation(AggregationBuilders.cardinality("authorNameAgg").field("author_name"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);Aggregations aggregations = resp.getAggregations();Cardinality cardinality = aggregations.get("authorNameAgg");String name = cardinality.getName();long value = cardinality.getValue();System.out.println(name + "=" + value);
}

6.5.8.2 范围统计

统计一定范围内出现的文档个数，比如，针对某一个Field的值在 0_100,100200,200~300之间文档出现的个数分别是多少。

范围统计可以针对普通的数值，针对时间类型，针对ip类型都可以做相应的统计。

range，date_range，ip_range

GET /article/_search
{"aggs": {"publishDateAgg": {"range": {"field": "publish_date","ranges": [{"from": "2022-11-01", "to": "2022-11-10"},{"from": "2022-11-11", "to": "2022-11-20"},{"from": "2022-11-21", "to": "2022-11-30"}]}}}
}

测试：

@Test
public void rangeAggregationTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.aggregation(AggregationBuilders.dateRange("publishDateAgg").field("publish_date").addRange("2022-11-01", "2022-11-10").addRange("2022-11-11", "2022-11-20").addRange("2022-11-21", "2022-11-30"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);Aggregations aggregations = resp.getAggregations();Range range = aggregations.get("publishDateAgg");List<? extends Range.Bucket> buckets = range.getBuckets();buckets.forEach(bucket -> {String key = bucket.getKeyAsString();long docCount = bucket.getDocCount();System.out.println(key + " => " + docCount);});
}

6.5.8.2 统计聚合查询

可以查询指定Field的最大值，最小值，平均值，平方和等

GET /article/_search
{"aggs": {"agg": {"extended_stats": {"field": "publish_date"}}}
}

测试：

@Test
public void extended_statsAggregationTest() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest("article");//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.aggregation(AggregationBuilders.extendedStats("agg").field("publish_date"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);Aggregations aggregations = resp.getAggregations();ExtendedStats extendedStats = aggregations.get("agg");String minAsString = extendedStats.getMinAsString();String maxAsString = extendedStats.getMaxAsString();String avgAsString = extendedStats.getAvgAsString();System.out.println(minAsString);System.out.println(maxAsString);System.out.println(avgAsString);
}

第七节倒排索引

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

将存放的数据，以一定的方式进行分词，并且将分词的内容存放到一个单独的分词库中。

当用户去查询数据时，会将用户的查询关键字进行分词。

然后去分词库中匹配内容，最终得到数据的id标识。

根据id标识去存放数据的位置拉取到指定的数据。