ElasticSearch学习笔记

狂神bilibili视频地址：https://www.bilibili.com/video/BV17a4y1x7zq

一、简介

1、本教程基于ElasticSearch7.6.1, 注意ES7的语法与ES6的API调用差别很大, 教程发布时最新版本为ES7.6.2

ES是用于全文搜索的工具:
SQL: 使用like %关键词%来进行模糊搜索在大数据情况下是非常慢的, 即便设置索引提升也有限;
ElasticSearch: 搜索引擎(baidu, github, taobao)

2、一些ES涉及的概念:

分词器 ik
Restful操作ES
CRUD
SpringBoot集成ES

Lucene库创始人 Doug Cutting

Lucene: java写成的为各种中小型应用软件加入全文检索功能;
Nutch: 一个建立在Lucene核心之上的网页搜索应用程序, Nutch的应用比Lucene要更加广泛
大数据解决存储与计算(MapReduce)两个问题:

  • 2004年Doug Cutting基于GFS系统开发了分布式文件存储系统;
  • 2005年Doug Cutting基于MapReduce在Nutch搜索引擎实现了这种算法;
  • 加入Yahoo后, Doug Cutting将MapReduce和NDFS结合创建了Hadoop, 成为了Hadoop之父;

Doug Cutting将BigTable集成到Hadoop中

回到主题:

  1. Lucene是一套信息检索工具包, jar包, 不包含搜索引擎系统;
  2. Lucene包含索引结构, 读写索引的工具, 排序, 搜索规则, 工具类;
  3. Lucene和ES的关系:
  4. ES是基于Lucene做了一些封装和增强, 上手是比较简单的, 比Redis要简单

Elastic概述

分布式的全文搜索引擎, 高扩展性;
接近实时更新的查询搜索;
ES是基于Restful的(即用get, post, delete, put来访问);
ES进行复杂的数据分析, ELK技术(elastic+logstash+kibana)

Elastic vs solr

  1. 当使用索引时, solr会发生io阻塞, 查询性较差, elastic则在索引情况下的优势明显;
  2. elastic的效率在传统项目下一般有50倍的提升;
  3. elastic解压即可用, solr需要配置
  4. solr用zookeeper进行分布式管理, elastic自带分布式
  5. solr支持更多格式的数据, json, xml, csv, elastic只支持json
  6. solr比elastic的功能更强大
  7. solr查询快, 但是更新索引时慢(如插入和删除慢), elastic查询慢, 但是实时性查询快, 用于facebook新浪等搜索
  8. solr是传统搜索应用的解决方案, elastic适用于新兴的实时搜索应用
  9. solr比较成熟, elastic目前更新换代快;

二、环境搭建：

jdk

官网的文档中可以找到ElasticSearch对jdk的最低要求：https://www.elastic.co/cn/support/matrix#matrix_jvm

 ElasticSearch软件包下载(百度云)

链接：https://pan.baidu.com/s/1kbx0-d-E2Z2g3jr3kdo62A
提取码：8023

ES目录结构 

bin：启动文件
config：配置文件
	log4j2 日志文件
	jvm.options 虚拟机文件
	elasticsearch.yml 配置文件  比如默认9200端口
lib：相关jar包

modules：功能模块
plugins：插件：比如ik插件

ES的启动与访问

在ES的bin目录双击elasticsearch.bat文件即可启动ES

 访问ES：在浏览器访问：localhost:9200

 

ElasticSearch Head监控工具：

在百度云链接里面了，解压可用

GitHub地址：https://github.com/mobz/elasticsearch-head

chrom浏览器可以添加ElasticSearch Head插件

Head监控工具的使用：

1、电脑上面要有nodejs环境

2、进入到软件的解压目录，从里面cmd进入dos窗口

3、执行命令：

cnpm install

cnpm run start #启动插件：localhost:9100

4、浏览器访问localhost:9100发现连接不上ES，这就是跨域问题

解决跨域连接问题 

进入ES的config目录修改elasticsearch.yml文件，添加并保存：

http.cors.enabled: true
http.cors.allow-origin: "*"

Kibana数据可视化工具的使用

　　ELK是Elasticsearch、Logstash、 Kibana三大开源框架首字母大写简称。市面上也被成为Elastic Stack。其中Elasticsearch是一个
基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。

　　像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用Elasticsearch作为底层支持框架,可见Elasticsearch提供的搜索能力确实强大，市面上很多时候我们简称Elasticsearch为es.

Logstash是ELK的中央数据流引擎,用于从不同目标(文件/数据存储/MQ )收集的不同格式数据,经过过滤后支持输出到不同目的地(文件/MQ/redis/elasticsearch/kafka等)。

　　Kibana可以将elasticsearch的数据通过友好的页面展示出来 ,提供实时分析的功能。
　　市面上很多开发只要提到ELK能够-致说出它是一 个日志分析架构技术栈总称 ,但实际上ELK不仅仅适用于日志分析,它还可以支持其它任何数据分析和收集的场景,日志分析和收集只是更具有代表性。并非唯一性。

官网地址：https://www.elastic.co/cn/kibana

解压网盘里面的即可！

  • 1、先启动ES
  • 2、配置Kabana的汉化

　　　　从kibana-7.6.1-windows-x86_64\x-pack\plugins\translations\translations\zh-CN.json可以找到汉化的文件

　　　　修改config/kibana.yml文件

　　　　

  •  3、启动kibana

　　　　在启动ES的环境下，进入到kibana的bin目录，双击kibana.bat即可启动

  • 4、访问localhost:5601

三、 ES核心概念

集群，节点，索引，类型，文档，分片，映射是什么？

elasticsearch是面向文档，关系型数据库和elasticsearch客观的对比！一切都是json

物理设计：

　　elasticsearch在后台把每个索引划分成多个分片。每个分片可以在集群中的不同服务器间迁移

逻辑设计：

　　一个索引类型中，抱哈an多个文档，当我们索引一篇文档时，可以通过这样的一个顺序找到它：索引-》类型-》文档id，通过这个组合我们就能索引到某个具体的文档。注意：ID不必是整数，实际上它是一个字符串。

文档

就是我们的一条条的记录

之前说elasticsearch是面向文档的,那么就意味着索弓和搜索数据的最小单位是文档, elasticsearch中,文档有几个重要属性:

  • 自我包含, 一篇文档同时包含字段和对应的值,也就是同时包含key:value !
  • 可以是层次型的，-一个文档中包含自文档,复杂的逻辑实体就是这么来的! {就是一 个json对象! fastjson进行自动转换!}
  • 灵活的结构,文档不依赖预先定义的模式,我们知道关系型数据库中,要提前定义字段才能使用,在elasticsearch中,对于字段是非常灵活的,有时候,我们可以忽略该字段,或者动态的添加一个新的字段。

尽管我们可以随意的新增或者忽略某个字段,但是,每个字段的类型非常重要,比如一个年龄字段类型,可以是字符串也可以是整形。因为elasticsearch会保存字段和类型之间的映射及其他的设置。

这种映射具体到每个映射的每种类型,这也是为什么在elasticsearch中,类型有时候也称为映射类型。

类型

　　类型是文档的逻辑容器,就像关系型数据库一样,表格是行的容器。类型中对于字段的定 义称为映射,比如name映射为字符串类型。

　　我们说文档是无模式的 ,它们不需要拥有映射中所定义的所有字段,比如新增一个字段,那么elasticsearch是怎么做的呢?elasticsearch会自动的将新字段加入映射,但是这个字段的不确定它是什么类型, elasticsearch就开始猜,如果这个值是18 ,那么elasticsearch会认为它是整形。

　　但是elasticsearch也可能猜不对 ，所以最安全的方式就是提前定义好所需要的映射,这点跟关系型数据库殊途同归了,先定义好字段,然后再使用,别整什么幺蛾子。

索引

就是数据库!

　　索引是映射类型的容器, elasticsearch中的索引是一个非常大的文档集合。索|存储了映射类型的字段和其他设置。然后它们被存储到了各个分片上了。我们来研究下分片是如何工作的。

物理设计:节点和分片如何工作

　　一个集群至少有一 个节点,而一个节点就是一-个elasricsearch进程 ,节点可以有多个索引默认的,如果你创建索引,那么索引将会有个5个分片( primary shard ,又称主分片)构成的,每一个主分片会有一个副本( replica shard ,又称复制分片）

上图是一个有3个节点的集群,可以看到主分片和对应的复制分片都不会在同-个节点内,这样有利于某个节点挂掉了,数据也不至于丢失。实际上, 一个分片是- -个Lucene索引, 一个包含倒排索引的文件目录,倒排索引的结构使得elasticsearch在不扫描全部文档的情况下,就能告诉你哪些文档包含特定的关键字。不过,等等,倒排索引是什么鬼?

倒排索引

　　elasticsearch使用的是一种称为倒排索引 |的结构,采用Lucene倒排索作为底层。这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成,对于每一个词,都有一个包含它的文档列表。

例如,现在有两个文档，每个文档包含如下内容:

Study every day， good good up to forever  # 文档1包含的内容
To forever, study every day，good good up  # 文档2包含的内容

为创建倒排索引,我们首先要将每个文档拆分成独立的词(或称为词条或者tokens) ,然后创建一一个包含所有不重 复的词条的排序列表,然后列出每个词条出现在哪个文档:

 现在，我们试图搜索 to forever，只需要查看包含每个词条的文档

 

两个文档都匹配,但是第一个文档比第二个匹配程度更高。如果没有别的条件,现在,这两个包含关键字的文档都将返回。
再来看一个示例,比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构:

 

如果要搜索含有python标签的文章,那相对于查找所有原始数据而言，查找倒排索引后的数据将会快的多。只需要查看标签这一栏,然后获取相关的文章ID即可。完全过滤掉无关的所有数据,提高效率!

elasticsearch的索引和Lucene的索引对比：

　　在elasticsearch中，索引(库)这个词被频繁使用,这就是术语的使用。在elasticsearch中 ,索引被分为多个分片,每份分片是-个Lucene的索引。所以一个elasticsearch索引是由多 个Lucene索引组成的。

　　别问为什么,谁让elasticsearch使用Lucene作为底层呢!如无特指，说起索引都是指elasticsearch的索引。

接下来的一切操作都在kibana中Dev Tools下的Console里完成基础操作!

四、ik分词器(掌握)

什么是IK分词器 ?

　　分词:即把一-段中文或者别的划分成一个个的关键字,我们在搜索时候会把自己的信息进行分词,会把数据库中或者索引库中的数据进行分词,然后进行一个匹配操作,默认的中文分词是将每个字看成一个词,比如“我爱狂神”会被分为"我",“爱”,“狂”,“神” ,这显然是不符合要求的,所以我们需要安装中文分词器ik来解决这个问题。

如果要使用中文,建议使用ik分词器!

IK提供了两个分词算法: ik_ smart和ik_ max_ word ,其中ik_ smart为最少切分, ik_ max_ _word为最细粒度划分!一会我们测试!

什么是IK分词器：

  • 把一句话分词
  • 如果使用中文：推荐IK分词器
  • 两个分词算法：ik_smart（最少切分），ik_max_word（最细粒度划分）

ik分词器的使用

ik分词器的GitHub地址：https://github.com/medcl/elasticsearch-analysis-ik

下载上面网盘提供的分词器、

只需要将ik分词器解压到ES的plugins(插件)中即可：

ik分词器的测试：

【ik_smart】测试：

【ik_max_word】测试：

 

 使用分词器确实能够将数据给分开，但是发现一个问题：明明在我们意识中大数据是一个词，这两种分词器把大数据拆开了。

编写自己的扩展字典

 在ES的ik分词器插件目录下的config文件新建一个属于自己的字典：\ElasticSearchEnvironment\elasticsearch-7.6.1-windows-x86_64\elasticsearch-7.6.1\plugins\ik\config\zhixi.dic

扩展字典里面写自己认为的一组词，一行算一组

 重启ES跟Kibana进行测试：

 

 

五、命令模式的使用(重点)

rest风格：关于索引的基本操作：

　　一种软件架构风格，而不是标准。更易于实现缓存等机制

1、PUT 创建一个索引

PUT /索引名/类型名(高版本都不写了，都是_doc)/文档id

{

请求体

}

2、PUT 创建数据库索引以及对应字段

 

 

 在ES-head中查看数据：

 3、GET查看具体的文档信息

 

4、GET ES默认配置字段类型 

如果我们创建索引的时候，并没有指定这个文档的类型，会怎么样呢？

说明：在后面的版本中默认是_doc,可以显示的声明或者不进行声明

PUT /test3/_doc/1
{
  "name": "张志喜",
  "age": 21,
  "birthday": "2000-03-05"
}

查看test3的默认类型：GET /test3

 5、GET _cat 拓展命令

 6、修改值

  • 1、PUT覆盖方式

 

  •  2、POST 修改指定的字段

 

关于文档的基本操作(回顾上面)

1、添加数据 PUT

PUT /zhixi/user/1
{
  "name": "张志喜",
  "age": 21,
  "address": "河南信阳",
  "interest": ["抽烟","喝酒","烫头"]
}

 2、获取数据 GET

……

3、修改数据 PUT

实际上是将原来的数据给覆盖掉

 4、修改数据 POST

修改指定的字段：

 ES搜索（重点）

1、简单的查询

_search:

2、复杂操作搜索select (排序，分页，高亮，模糊查询，精准查询! )

查询：query

GET zhixi/user/_search
{
  "query": {
    "match": {
      "address": "河南"
    }
  }
  , "_source": ["name","interest"]
}

过滤：_source

 

排序：sort

分页：form size

布尔值查询：bool

must表示and

 should表示or

过滤：filter

eq相等 ne、neq不相等， gt大于， lt小于 gte、ge大于等于 lte、le 小于等于 not非 mod求模 等

 匹配多个条件

3、关于分词

  • term，直接查询精确的
  • match，会使用分词器解析！（先分析文档，然后通过分析的文档进行查询）
  • text类型 会被当做分词器解析
  • keyword类型 不会被当做分词器解析(精确查找)

可以看到默认的被分词了，而keyword没有被分词

 4、精确查询多个值：

POST dbdemo/_doc/3
{
  "t1": 21,
  "birthday": "2000-01-01"
}

POST dbdemo/_doc/4
{
  "t1": 22,
  "birthday": "1999-01-01"
}

GET dbdemo/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
              "t1": 21
          }
        },
        {
          "term": {
              "t1": 22
          }
        }
      ]
    }
  }
}

 

 5、高亮查询

 

 六、ES集成SpringBoot

1、准备（前言）

1、找文档

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、找原生依赖

在这里插入图片描述

3、找对象

在这里插入图片描述

4、分析这个类中的方法即可

  • 配合基本的项目

问题：一定要保证我们导入的依赖和我们es版本一致
在这里插入图片描述
自定义版本

在这里插入图片描述

源码中提供的对象！

虽然这里导入了3个类，静态内部类，核心类就一个。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2、具体的API测试

1、索引的创建、查看。删除

@SpringBootTest
class ZhixiEsApiApplicationTests {

    @Autowired
    @Qualifier("restHighLevelClient")
    RestHighLevelClient clients;

    // 创建索引
    @Test
    void contextLoads1() throws IOException {
        // 1、创建索引
        CreateIndexRequest request = new CreateIndexRequest("zhixi");
        // 2、客户端执行请求(请求选项默认)
        CreateIndexResponse createIndexResponse = clients.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse); // CreateIndexResponse@6fba1cb
    }

    // 获取索引请求
    @Test
    void contextLoads2() throws IOException {
        // 1、获取索引
        GetIndexRequest request = new GetIndexRequest("zhixi");
        // 查看索引是否存在
        boolean exists = clients.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);// true
    }

    //  删除索引请求
    @Test
    void contextLoads3() throws IOException {
        // 获取要删除的索引
        DeleteIndexRequest request = new DeleteIndexRequest("zhixi");
        // 客户端执行删除操作
        AcknowledgedResponse delete = clients.indices().delete(request, RequestOptions.DEFAULT);
        // 判断是否删除成功
        System.out.println(delete.isAcknowledged()); // true
    }

}

2、文档的创建、添加、修改、删除、以及批量添加文档

// 测试添加文档
@Test
void testAddDocument() throws IOException {
    // 1、创建对象
    User user = new User("张志喜", 21);
    // 2、创建索引请求
    IndexRequest request = new IndexRequest("zhixi_index");
    // 设置规则
    request.id("1");
    request.timeout("1s");
    // 3、将我们的数据放入请求(指定内容类型)
    request.source(JSONObject.toJSONString(user), XContentType.JSON);
    // 4、客户端发送请求，获取相应结果
    IndexResponse indexResponse = clients.index(request, RequestOptions.DEFAULT);
    System.out.println(indexResponse);
    // 查看状态
    System.out.println(indexResponse.status());// CREATED
}
// 测试文档是否存在
@Test
void testIsDocument() throws IOException {
    // 获取文档请求
    GetRequest request = new GetRequest("zhixi_index", "1");
    boolean exists = clients.exists(request, RequestOptions.DEFAULT);
    System.out.println(exists);
}
// 获取文档信息
@Test
void testGetDocument() throws IOException {
    // 获取文档请求
    GetRequest request = new GetRequest("zhixi_index", "1");
    GetResponse response = clients.get(request, RequestOptions.DEFAULT);
    /**
     * 打印文档信息
     * {"_index":"zhixi_index","_type":"_doc","_id":"1","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"age":21,"name":"张志喜"}}
     */
    System.out.println(response);
    /**
     * name：张志喜
     * age：21
     */
    Map<String, Object> map = response.getSource();
    map.forEach((key, value) -> {
        System.out.println(key + "：" + value);
    });
}
// 文档的更新
@Test
void testUpdateDocument() throws IOException {
    // 1、获取更新请求
    UpdateRequest request = new UpdateRequest("zhixi_index", "1");
    User user = new User("共产主义接班人", 18);
    // 2、设置未指定脚本时用于更新的文档
    request.doc(JSONObject.toJSONString(user), XContentType.JSON);
    // 3、执行更新
    UpdateResponse response = clients.update(request, RequestOptions.DEFAULT);
    // 4、查看更新状态
    System.out.println(response.status());
}
// 删除文档记录
@Test
void testDelDocument() throws IOException {
    // 获取删除请求
    DeleteRequest request = new DeleteRequest("zhixi_index", "1");
    DeleteResponse deleteResponse = clients.delete(request, RequestOptions.DEFAULT);
    // 查看删除状态
    System.out.println(deleteResponse.status()); // OK
}
// 测试批量添加文档
@Test
void addBulkDocument() throws IOException {
    // 1、获取批量添加的请求
    BulkRequest bulkRequest = new BulkRequest();
    ArrayList<User> list = new ArrayList<>();
    for (int i = 1; i <= 10; i++) {
        list.add(new User("Java小白" + i + "号", i));
    }
    // 2、批量处理
    for (int i = 0; i < list.size(); i++) {
        // 执行批量更新以及删除等操作
        bulkRequest.add(
                new IndexRequest("zhixi_index")
                // 不设置id会生成随机id
                .id(""+(i+1))
                .source(JSONObject.toJSONString(list.get(i)),XContentType.JSON)
        );
    }
    // 3、执行
    BulkResponse bulkResponse = clients.bulk(bulkRequest, RequestOptions.DEFAULT);
    // 4、查看是否执行失败
    System.out.println(bulkResponse.hasFailures());
}

3、测试查询

 /**
  * 测试查询
  * SearchRequest 搜索请求
  * SearchSourceBuilder 条件构造
  * HighlightBuilder构建高亮
  * TermQueryBuilder精确查询
  * MatchAL LQueryBuilder
  * xxx QueryBuilder 对应我们刚才看到的命令!
  */
 @Test
 void testQuery() throws IOException {
     // 1、创建搜索要求
     SearchRequest searchRequest = new SearchRequest("zhixi_index");
     // 2、构建查询条件，通过工具类来生成
     SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
     // 注意：如果有大写的英文字母，或者分词器中没有将你的数据当做一个词语的时候，需要在查询字段后面添加上.keyword
     sourceBuilder.query(QueryBuilders.termQuery("name.keyword", "Java小白1号"));
     sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
     // 3、将条件添加到搜索中
     searchRequest.source(sourceBuilder);
     // 4、返回查询的响应结果
     SearchResponse searchResponse = clients.search(searchRequest, RequestOptions.DEFAULT);
     // 返回JSON格式数据
     System.out.println(JSONObject.toJSONString(searchResponse.getHits()));
     System.out.println("===============================");
     // 打印响应结果对象里面所有的数据
     for (SearchHit hit : searchResponse.getHits().getHits()) {
         System.out.println(hit.getSourceAsMap());
     }
 }

七、实战

需要导入的依赖：

 <!--爬虫所需要的的依赖：爬取网页-->
 <dependency>
     <groupId>org.jsoup</groupId>
     <artifactId>jsoup</artifactId>
     <version>1.13.1</version>
 </dependency>

数据问题？数据库获取，小消息队列中获取，都可以成为数据源，爬虫！

1、爬取数据

获取请求返回的页面信息，筛选出我们想要的数据就可以了！使用jSoup包。

public static void main(String[] args) throws Exception {
        // 1、获取请求
        String url = "https://search.jd.com/Search?keyword=java";
        // 2、解析网页
        Document document = Jsoup.parse(new URL(url), 30000);
        // 3、获得的就是网页对象
        Element element = document.getElementById("J_goodsList");
        // System.out.println(element.html());

        // 获取所有的li元素(商品)
        Elements elementsByTag = element.getElementsByTag("li");
        for (Element li : elementsByTag) {
            // 获取商品的名称、价格、图片、
            String name = li.getElementsByClass("p-name").eq(0).text();
            String price = li.getElementsByClass("p-price").eq(0).text();
            String img = li.getElementsByTag("img").eq(0).attr("data-lazy-img");
            // 打印信息
            System.out.println(name);
            System.out.println(price);
            System.out.println(img);
        }
    }

 2、爬取数据放到ES中

引入ES的配置类(连接ES)：config/ElasticSearchClientConfig

@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("127.0.0.1", 9200, "http"))
        );
        return client;
    }
}

将上面的爬取数据封装成为一个工具类：HTMLPageUtil

**
 * @author zhangzhixi
 * @date 2021/3/6 11:23
 */
public class HTMLParseUtil {

    public static List<Content> getJd(String commodity) throws Exception {
        // 1、获取请求
        String url = "https://search.jd.com/Search?keyword=" + commodity + "&enc=utf-8";
        // 2、解析网页
        Document document = Jsoup.parse(new URL(url), 30000);
        // 3、获得的就是网页对象
        Element element = document.getElementById("J_goodsList");
        // System.out.println(element.html());

        // 获取所有的li元素(商品)
        Elements elementsByTag = element.getElementsByTag("li");
        ArrayList<Content> list = new ArrayList<>();
        for (Element li : elementsByTag) {
            // 获取商品的名称、价格、图片、
            String name = li.getElementsByClass("p-name").eq(0).text();
            String price = li.getElementsByClass("p-price").eq(0).text();
            String img = li.getElementsByTag("img").eq(0).attr("data-lazy-img");
            // 设置商品
            Content content = new Content(name, price, img);
            // 将商品添加到集合中
            list.add(content);
        }
        return list;
    }
}

service层编写：

@Autowired
private RestHighLevelClient restHighLevelClient;
/**
 * 1、解析数据放入到es索引库中
 *
 * @param keyWord 要查询的关键字
 * @return 成功或者失败
 */
public boolean setDateIndex(String keyWord) throws Exception {
    List<Content> contentList = HTMLParseUtil.getJd(keyWord);
    // 2、将查询到的数据放入es（批量添加）
    BulkRequest bulkRequest = new BulkRequest();
    for (int i = 0; i < contentList.size(); i++) {
        bulkRequest.add(
                new IndexRequest("jd_test")
                        .source(JSON.toJSONString(contentList.get(i)), XContentType.JSON)
        );
    }
    BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    return !bulk.hasFailures();
}

controller层编写：

@RestController
public class ContentController {
    @Autowired
    ContentService contentService;
    /**
     * 数据的添加
     */
    @GetMapping("/parse/{keyword}")
    public boolean parseJD(@PathVariable("keyword") String keyword) throws Exception {
        return contentService.setDateIndex(keyword);
    }
}

测试：

开启ES，浏览器访问：localhost:9090/parse/java

 

 

3、查询ES中添加的数据

service层：

// 2、实现数据搜索功能
public List<Map<String, Object>> searchPage(String keyword,int pageNo,int pageSize) throws IOException {
    // 条件搜索
    SearchRequest searchRequest = new SearchRequest("jd_test");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    // 分页
    sourceBuilder.from(pageNo);
    sourceBuilder.size(pageSize);
    // 精准匹配
    TermQueryBuilder termQuery = QueryBuilders.termQuery("name", keyword);
    sourceBuilder.query(termQuery);
    // 执行搜索
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    ArrayList<Map<String, Object>> list = new ArrayList<>();
    // 解析结果
    for (SearchHit hit : searchResponse.getHits().getHits()) {
        list.add(hit.getSourceAsMap());
    }
    return list;
}

controller层：　　

/**
 * 数据的搜索
 */
@GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
public List<Map<String, Object>> searchPage(
        @PathVariable("keyword") String keyword,
        @PathVariable("pageNo") int pageNo,
        @PathVariable("pageSize") int pageSize) throws IOException {
    return contentService.searchPage(keyword, pageNo, pageSize);
}

测试：

 

 

　　

　　

 

posted @ 2021-03-04 22:02  Java小白的搬砖路  阅读(210)  评论(0)    收藏  举报