[大数据]ElasticSearch

目录???????

概述

安装

可视化界面?

ELK

安装Kibana

ES核心概念

关系型数据库和elasticsearch的对比

文档

类型

索引

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

倒排索引

elasticsearch的索引和lucene索引对比

IK分词器

安装

自定义分词

Rest风格说明

创建一个索引

?基本类型

指定字段类型

?扩展

?修改索引

?删除索引

?复杂操作搜索

?布尔值查询

精确查询

高亮

?自定义高亮

?集成SpringBoot

概述

es是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据，本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es也使用java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文检索变得简单。

安装

中文官网：Elasticsearch：官方分布式搜索和分析引擎 | Elastic

版本：7.6.2

下载地址：https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.6.2-windows-x86_64.zip

解压

如果电脑性能不太好，可以去修改config目录下的jvm.options文件

?启动，双击bin目录下.bat

默认端口是9200，访问测试：127.0.0.1:9200

?

可视化界面?

?下载地址：https://github.com/mobz/elasticsearch-head

?启动

cnpm install

npm run start

解决跨域问题，修改es的配置文件elasticsearch.yml，添加如下配置

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

重启es，再次连接。

ELK

ELK是ElasticSearch、Logstash、Kibana三大开源框架首字母大写简称，市面上也被称为Elastic Stack。其中ElasticSearch是一个基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。Logstash是ELK的中央数据流引擎，用于从不同目标收集的不同格式数据，经过过滤后支持输出到不同目的地。Kibana可以将elasticsearch的数据通过友好的页面展示出来，提供实时分析的功能。

安装Kibana

下载地址：https://artifacts.elastic.co/downloads/kibana/kibana-7.6.2-windows-x86_64.zip

?解压并启动

?测试

开发工具

?汉化

打开config/kibana.yml文件修改以下配置

ES核心概念

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

elasticsearch是面向文档

关系型数据库和elasticsearch的对比

elasticsearch（集群）中可以包含多个索引（数据库），每个索引中可以包含多个类型（表），每个类型下又包含多个文档（行），每个文档中又包含多个字段（列）。

物理设计：

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

逻辑设计：

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

文档

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

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

尽管我们可以随意的新增或者忽略某个字段，但是每个字段的类型非常重要，比如一个年龄型字段，可以是字符也可以是整型。因为elasticsearch会保存字段和类型之间的映射及其他的设置。这种映射具体到每个映射的每种类型，这也是为什么在elasticsearch中，类型有时候也称为映射类型。

类型

类型是文档的逻辑容器，就像关系型数据库一样，表格是行的容器。类型中对于字段的定义称为映射，比如name映射为字符串类型。我们说文档是无模式的，它们不需要拥有映射中所定义的所有字段，比如新增一个字段，那么elasticsearch是怎么做的呢 ？elasticsearch会自动的将新字段加入映射，但是这个字段不确定它是什么类型，elasticsearch就开始猜，如果这个值是18，那么elasticsearch会认为它是整型。但是elasticsearch也可能猜不对，所以最安全的方式就是提前定义好所需要的映射，这点跟关系型数据库殊途同归，先定义好字段，然后在使用。

索引

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

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

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

上图是一个有三个节点的集群，可以看到主分片和对应的复制分片都不会在同一个节点内，这样有利于某个节点挂掉了，数据也不至于丢失。实际上，一个分片是一个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索引组成的。

IK分词器

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

ik提供了两个分词算法：ik_smart和ik_max_word，其中ik_smart为最少切分，ik_max_word为最细粒度划分。

安装

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

2.在elasticearch的plugins目录下创建ik文件夹，在ik文件夹下解压

3.重启es，重启kibana

?

自定义分词

在ik文件夹下config目录下，新建***.dic文件，修改配置文件IKAnalyzer.cfg.xml

Rest风格说明

基本Rest命令说明

创建一个索引

语法：put? /索引名/类型名/文档ID

PUT /test1/user/1
{
  "name": "zhangsan",
  "age": 3
}

?基本类型

• 字符串类型：text、keyword
• 数值类型：long、integer、short、byte、double、float、half float、scaled float
• 日期类型：date
• 布尔类型：boolean
• 二进制类型：binary
• 。。。

指定字段类型

获取具体的信息

?扩展

查看健康值：GET _cat/health

查看索引信息：GET _cat/indices?v

?修改索引

?删除索引

?复杂操作搜索

?match：匹配查询

结果字段过滤：_source?

?排序：sort

?分页：from size

?布尔值查询

?must （and）

?should (or)

?must_not (not)

?filter: 数据过滤

• ?lt: 小于
• lte：小于等于
• gt：大于
• gte : 大于等于

精确查询

term查询是直接通过倒排索引指定的词条进行精确的查找

?注：如果字段类型是keyword，则不会进行分词搜索。

高亮

?自定义高亮

?集成SpringBoot

1.引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.demo</groupId>
    <artifactId>es-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>es-api</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <elasticsearch.version>7.6.2</elasticsearch.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
</project>

2.创建ES配置类

package com.demo.esapi.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EsConfig {

    @Bean
    public RestHighLevelClient restHighLevelClient(){
        return new RestHighLevelClient(
                RestClient.builder(
                new HttpHost("localhost", 9200, "http")));
    }
}

3.测试

package com.demo.esapi;

import com.alibaba.fastjson.JSON;
import com.demo.esapi.pojo.User;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class EsApiApplicationTests {

    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    @Test
    void contextLoads() {
    }


    /**
     * 创建索引
     */
    @Test
    void createIndex() throws IOException {
        //创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("demo_index");
        //执行请求
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

    }

    /**
     * 获得索引
     */
    @Test
    void getIndex() throws IOException {
        //创建索引请求
        GetIndexRequest request = new GetIndexRequest("demo_index");
        //获取索引是否存在
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        if(exists){
            GetIndexResponse getIndexResponse = client.indices().get(request, RequestOptions.DEFAULT);
            System.out.println(getIndexResponse);
        }
    }

    /**
     * 删除索引
     */
    @Test
    void deleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("demo_index");

        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

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

    }


    /**
     * 创建文档
     */
    @Test
    void addDoc() throws IOException {
        User user = new User("张三",1);

        IndexRequest request = new IndexRequest("demo_index");

        request.id("1");
        //设置超时时间
        request.timeout(TimeValue.timeValueSeconds(1));

        //将数据放入请求，json
        request.source(JSON.toJSONString(user),XContentType.JSON);

        //客户端发送请求，获取响应结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

        System.out.println(indexResponse.toString());
        //获取返回的状态 CREATED
        System.out.println(indexResponse.status());
    }

    /**
     * 获得文档
     */
    @Test
    void getDoc() throws IOException {
        GetRequest request = new GetRequest("demo_index","1");
        //是否回去_source上下文
        request.fetchSourceContext(new FetchSourceContext(true));

        boolean exists = client.exists(request, RequestOptions.DEFAULT);
        if(exists){
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            System.out.println(response.toString());
            //{"_index":"demo_index","_type":"_doc","_id":"1","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"age":1,"name":"张三"}}
        }
    }

    /**
     * 更新文档
     */
    @Test
    void updateDoc() throws IOException {
        UpdateRequest request = new UpdateRequest("demo_index","1");

        request.timeout(TimeValue.timeValueSeconds(1));

        User user = new User("李四",2);

        request.doc(JSON.toJSONString(user), XContentType.JSON);

        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
        //[index=demo_index,type=_doc,id=1,version=2,seqNo=1,primaryTerm=1,result=updated,shards=ShardInfo{total=2, successful=1, failures=[]}]
        
    }

    /**
     * 删除文档
     */
    @Test
    void deleteDoc() throws IOException {
        DeleteRequest request = new DeleteRequest("demo_index","1");

        request.timeout(TimeValue.timeValueSeconds(1));

        DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.toString());
        //[index=demo_index,type=_doc,id=1,version=3,result=deleted,shards=ShardInfo{total=2, successful=1, failures=[]}]

    }

    /**
     * 批量插入文档
     */
    @Test
    void batchAddDoc() throws IOException {
        BulkRequest request = new BulkRequest();

        request.timeout(TimeValue.timeValueSeconds(10));

        List<User> userList = new ArrayList<>();
        userList.add(new User("张三1",1));
        userList.add(new User("张三2",2));
        userList.add(new User("张三3",3));
        userList.add(new User("张三4",4));

        for (int i = 0; i < userList.size(); i++) {
            request.add(new IndexRequest("demo_index").id(""+(i+1)).source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
        }

        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.hasFailures());
    }

    /**
     * 搜索
     */
    @Test
    void search() throws IOException {
        SearchRequest searchRequest = new SearchRequest("demo_index");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("age","1");
        searchSourceBuilder.query(termQueryBuilder);


        searchSourceBuilder.timeout(new TimeValue(6, TimeUnit.SECONDS));

        System.out.println(JSON.toJSONString(searchSourceBuilder));

        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println(searchResponse);

    }
}