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);
}

    测试：

    　　

    　　
  • 相关阅读:
    cf1100 F. Ivan and Burgers
    cf 1033 D. Divisors
    LeetCode 17. 电话号码的字母组合
    LeetCode 491. 递增的子序列
    LeetCode 459.重复的子字符串
    LeetCode 504. 七进制数
    LeetCode 3.无重复字符的最长子串
    LeetCode 16.06. 最小差
    LeetCode 77. 组合
    LeetCode 611. 有效三角形个数
  • 原文地址：https://www.cnblogs.com/zhangzhixi/p/14483259.html
Copyright © 2011-2022 走看看