zoukankan      html  css  js  c++  java

  • 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_64x-packplugins ranslations ranslationszh-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文件新建一个属于自己的字典：ElasticSearchEnvironmentelasticsearch-7.6.1-windows-x86_64elasticsearch-7.6.1pluginsikconfigzhixi.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);
}

    测试：

    　　

    　　
  • 相关阅读:
    FreeSWITCH一些需求应对
    CentOS 7安装Mysql并设置开机自启动
    RTP学习笔记
    SDP学习笔记
    Quartz实用二三事
    Quartz：ERROR threw an unhandled Exception
    CentOS 7一些常用配置
    Java获取音频文件（MP3）的播放时长
    使用Callable和Future接口创建线程
    join() 方法详解及应用场景
  • 原文地址：https://www.cnblogs.com/zhangzhixi/p/14483259.html
Copyright © 2011-2022 走看看