ElaticSearch学习笔记

最新推荐文章于 2023-03-01 11:13:42 发布

曾是惊鸿照影来`

最新推荐文章于 2023-03-01 11:13:42 发布

阅读量239

点赞数 1

分类专栏：大数据搜索引擎 ElasticSearch 文章标签： elasticsearch

本文链接：https://blog.csdn.net/qq_49250154/article/details/118605319

版权

大数据同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

搜索引擎

1 篇文章 0 订阅

订阅专栏

ElasticSearch

1 篇文章 0 订阅

订阅专栏

ElasticSearch学习笔记

了解一个人：

Doung Cutting 美国工程师 Lucence Nutch Hadoop都是出自他手被称为 hadoop 之父

ElasticSearch 是 Shay Banon 基于Lucene 开发的开发了他第一个开源项目 compass 最后叫做 ElasticSearch

Lucence 是一套 信息检索工具包 jar包不包含搜索引擎系统

包含的：索引结构读写索引的工具排序搜索规则工具类

Lucene和ElasticSearch关系

ElasticSearch 是基于Lucene做了一些封装和增强

ElasticSearch概述：

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

ElasticSearch 与 Solr 比较

当单纯的对已有数据进行搜索时，Solr更快

当实时建立索引，Solr会产生io阻塞，查询性能较差，ElasticSearch具有明显优势随着数据量额增加，Sorl的搜索效率会变得更低，而ElasticSearch 却没有明显的变化

总结：

es是开箱即用（解压就可以用）比较简单
Solr是基于Zookeeper进行分布式管理，而ElasticSearch自身带有分布式协调管理功能
Solr支持更多格式的数据比如JSON XML CSV 而ElasticSearch 仅支持JSON
Solr官方提供的功能更多，而ElasticSearch本身更注重于核心功能，高级功能多有第三方插件提供比如图形化界面需要 kibana友好支持
Solr 查询快但更新索引慢（插入删除慢）用于电商查询多的应用

ES 建立索引快（查询慢）实时性查询快，用于facebook 新浪等搜索

Solr 是传统搜索应用的有力解决方案但ElasticSearch更适用于新兴的实时搜索应用
Solr 比较成熟，有一个更大更成熟的用户、开发和贡献社区而ElasticSearch相对开发维护者较少，更新太快学习使用成本较高

ElasticSearch 安装

声明： JDK1.8 最低要求

基于JAVA开发 ElasticSearch 的版本和我们之后对应的JAVA的核心JAR包版本对应 JDK环境是正常

目录：

bin  		# 启动文件
config 		# 配置文件
   log4j2   # 日志配置文件
   jvm.options    # java 虚拟机相关的配置
   elasticsearch.yml  # elasticsearch 的配置文件 默认 9200端口 跨域！
lib        # 相关jar包
logs		# 日志
modules		# 模块
plugins		# 插件

启动：

双击 bin文件夹下的 elasticsearch.bat 文件 访问 9200

安装elasticsearch可视化插件

git下载elasticsearch-head

进入目录 cmd 运行 npm install ——> npm run start

需要实现跨域 ——> 在elasticsearch的config目录下的elasticsearch.yml 进行配置

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

ELK概述

ELK 是 elasticsearch logstash kibana 三大开源框架首字母简称，市面上也被称为Elastic Stack 其中elasticsearch 是一个基于Lucene 分布式通过Restful 方式进行交互的近实时搜索平台框架，像类似百度谷歌这种大数据全文搜索引擎的场景都可以使用elasticsearch作为底层支持框架可见elasticsearch 提供的搜索能力很强大

logstash 是 elk De中央数据流引擎用于从不同目标（文件/数据存储/MQ ）收集的不同格式数据经过过滤后支持输出到不同目的地（文件/MQ/redis/elasticsearch/kafka等） kibana 可以将elasticsearch的数据通过友好的页面展示出来，提供实时分析的功能

总结差不多分为三步：收集清洗数据（logstash ）——> 分析搜索存储（elasticsearch）——> kinaba（页面展示）

市面上很多开发只要提到ELK 能够一致说出他是一个日志分析架构技术栈总称，但实际上ELK不仅仅适用于日志分析，它还可以支持其他任何数据分析和收集的场景，日志分析和收集只是更具有代表性并非唯一性

kibana安装

好处： elk 基本都是开箱即用

启动点击bin目录下的 .bat文件

默认端口： 5601

访问测试：点击kinaba的左侧栏目的螺丝刀[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6dSfjHdx-1625810319935)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703152340367.png)]

汉化步骤：

找到kinaba解压目录点击config 下的 kibana.yml 添加配置默认是英文的 il8n.locale:“zh-CN”

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKZHLSIh-1625810319937)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703152622493.png)]

ES核心概念

索引
字段类型（mapping【映射】）
文档（documents）
分片（倒排索引）

ElasticSearch 是面向文档，关系型数据库和 ElasticSearch 客观对比： ElasticSearch 一切皆是json

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CpRkEfvs-1625810319939)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703153024633.png)]

物理设计：

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

分片：相当于倒排索引

一个ElasticSearch 也是一个集群默认的集群名称就是 ElasticSearch

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1qdWMemM-1625810319941)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703153341953.png)]

逻辑设计：

文档：就是一条条数据 (json格式后期可以通过fastjson自动转化)
```
user 
1 张三 18
2 李四 20
```
类型： String-> text …
索引：就相当于数据库创建索引之后才能去创建里面的东西索引是映射类型的容器，ElasticSearch 中的索引是一个非常大的文档集合，索引存储了映射类型的字段和其他设置，然后他们被存储在各个分片上

倒排索引：

数据：

study everyday , good good up   # doc_1
life is good study              # doc_2

term	doc_1	doc_2
study	√	√
everyday	√	x
…	…	…

现在试图搜索 study everyday 只需查看包含每个词条的文档

term	doc_1	doc_2
study	√	√
everyday	√	x
total	2	1

优先去权重（score）大的文档去搜索 doc_1 去搜索

示例2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-svkDoMUN-1625810319942)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703155347097.png)]

一个分片就相当于一个倒排索引

一个elasticsearch索引是由多个Lucene索引组成的 elasticsearch使用lucene作为底层

分词提示器（ik）

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

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

ik分词器安装

解压到ElasticSearch 的 plugins 文件夹下重启es 观察可以看到ik被加载

也可以通过 elasticsearch-plugin 来查看加载的插件

启动测试：

打开kinaba

# 所有的命令都是基于RESTFul风格
# analyze 分析的意思
GET _analyze
{
    "analyzer" : "ik_smart",
    "text" : "中国共产党"
}
GET _analyze
{
    "analyzer" : "ik_max_word",
    "text"  : "中国共产党"
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45dfdHym-1625810319943)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703162514549.png)]

搜索超级喜欢狂神说

发现被拆分了这种自己需要的词，需要我们自己加到我们的分词器的字典中

ik分词器增加自己的配置

搜索超级喜欢狂神说

发现被拆分了这种自己需要的词，需要我们自己加到我们的分词器的字典中

步骤：在ik安装目录找到config文件夹编写自己配置文件（.dic尾缀）注入到扩展字典中重启es

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u3C1syiJ-1625810319944)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703163138447.png)]

Restful风格说明

一种风格而不是标准通过不同的命令实现不同的操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PUF32yMf-1625810319945)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703163546356.png)]

关于索引的操作

基础测试：

创建一个索引

PUT  /索引名（相当于数据库名）/类型名（未来不一定有）/文档id   # 类型不写的话 默认是_doc
{
   请求体...
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tgWk73P8-1625810319946)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703164146818.png)]

2、在elasticsearch-head上查看效果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkQvqUqJ-1625810319947)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703164401324.png)]

3、那么name这个字段用不用指定类型呢毕竟我们关系型数据库是需要指定类型的

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

等等…

指定数据类型

PUT /test2    # 仅仅创建索引 相当于创建一个库
{
    "mappings":{
        "prooerties":{
            "name" : {
                "type" : "text"  # 指定数据类型
            },
            "age":{
                "type":"long"
            },
            "birthday":{
                "type" : "date"
            }
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ExWgLebf-1625810319948)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703165609569.png)]

获取该索引的规则

GET 索引/ 文档  # 查看索引或者文档的具体信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b3IlT7kU-1625810319948)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210703214335871.png)]

5、如果自己的文档字段类型没有指定，那么Es就会给我们默认配置字段类型

ES扩展命令

# _cat  信息
# GET _cat/  可以获取到es的很多信息
GET _cat/indices? v    # 查看包含的所有东西 比如 索引有多少个

修改索引

# 两种方式
# 第一种：  使用 PUT 相当于重新添加了
PUT /text3/_doc/1
{
    "name":"aaaa",
    "age": 12,
    "birthday":"2000-12-12"
}
# 第二种   _update
PUT /text3/_doc/1/_update
{
    "doc":{    # 必须要有doc
        "name": "法外狂徒张三"   # 要修改的数据
    }
}

# 总结区别： PUT 修改数据 如果请求体里的数据除了想要修改的之外 其他的和上次不同 或者 不写 则为空
#           _UPDATE  可以修改指定的数据 比如只修改name  请求体只写name就ok 灵活性更高

删除索引

DELETE /索引名  #删除索引（库）

关于文档的操作（重点）

添加数据

# 第一条
PUT /text/user/1
{
    "name": "zhangsan",
    "age":12,
    "tag": ["交友","法外狂徒"]
}
# 第二条
PUT /text/user/1
{
    "name": "李四",
    "age":1,
    "tag": ["交友","爱学习"]
}

获取数据

GET text/user/1  # 查询第一条

更新数据

# 第一种
PUT /text/user/1
{
    "name": "超大大"，
    "age":12,
    "tag": ["交友","法外狂徒"]
}
# 第二种
PUT /text/user/1/_update
{
    "doc" : {
         "name" : "李四"
    }
}

# 总结区别： PUT 修改数据 如果请求体里的数据除了想要修改的之外 其他的和上次不同 或者 不写 则为空
#           _UPDATE  可以修改指定的数据 比如只修改name  请求体只写name就ok 灵活性更高

查询数据

简单查询

GET text/user/1  # 通过id查询

简单条件查询

# GET 索引/类型/_search? 查询条件
GET text/user/_search?q=name:李四

复杂查询

排序、分页、高亮、模糊查询、精准查询

GET text/user/_search
{ 
    "query":{   # 查询的参数体 使用JSON构建
        "match":{   # 精准查询
            "name":"李四"  # 查询条件
        }
    }
}

# hits 
hits查出来的： 
索引和文档的信息
查询的结果总数
查询的具体文档（文档就是数据）
数据中的东西都可以遍历下来
分数： 可以通过分数来判断谁更加符合结果

输出结果字段属性不想要那么多

_source

GET text/user/_search
{
    "query":{
        "match":{
            "name":"张三"  # 查询条件
        }，
        "_source":["name","age"]  # 结果过滤 查询指定的字段信息 就相当于数据库中的 select * 变为了 select name,age 
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PrAZvyoJ-1625810319949)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704002741251.png)]

之后使用JAVA操作ES 所有的方法和对象就是这里面的key

排序

sort

GET text/user/_search
{
    "query":{
        "match":{
            "name":"李四"
        }
    }，
    "sort":[   # 排序
        {
            "age"：{   # 根据age 倒叙  
               "order" :"desc" 
            }
        }
    ]
}

分页查询

from 从第几条开始

size 返回几条数据

GET text/user/_search
{
    "query":{
        "match":{
            "name":"李四"
        }
    }，
    "sort":[   # 排序
        {
            "age"：{   # 根据age 倒叙  
               "order" :"desc" 
            }
        }
    ],
    "from" : 0,  # 从第几条开始
    "size" : 1   # 返回多少条数据
}

数据下标还是从0开始，和学的所有的数据结构一样

布尔值和Must查询

查询多个条件用bool构造

must (and) 都要满足

GET text/usr/_search
{
    "bool":{  # 布尔值查询 返回true / false
        "must":[  # 多条件查询 相当于数据库里的and
            "match":{
                "name":"李四"
            }，
            "match":{
                "age":1
            }
        ]
    }
}

shoud ( or ) 满足其一都可以

must_not （ not ）查出和条件不满足的不符合的

过滤器filter

gt 大于 gte 大于等于 lt 小于 lte 小于等于 e相当于equals

GET text/usr/_search
{
    "bool":{  # 布尔值查询 返回true / false
        "must":[  # 多条件查询 相当于数据库里的and
            "match":{
                "name":"李四"
            }，
            "match":{
                "age":1
            }
        ],
        "filter":{   # 过滤器查询
            "range":{
                "age":{
                    "lt":10   # 查询name等于李四 年龄大于10岁的
                }
            }
        }
    }
}

匹配多个条件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BNFa08mp-1625810319950)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704005656552.png)]

精确查询

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

关于分词：

term 直接查询精确的词
match 会使用分词器解析（先分析文档，然后通过分析的文档进行查询）

两个类型

text
keyword kewword 字段不会被分词器解析字段不会被分词器解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G8lPkKhR-1625810319951)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704010620733.png)]

standard 普通的分词

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2nyFoHBM-1625810319951)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704010547488.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OzfIxzlV-1625810319952)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704010928674.png)]

精确查询多个值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AmGs7ff0-1625810319953)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704011306537.png)]

高亮查询heighlight

GET text/user/_search
{
    "query":{
        "match":{
            "name":"狂神说"
        }
    }，
    "highlight":{  # 高亮
        "pre_tag": "<b>",   # 标签前缀 自己设置高亮的形式 默认的是<em>
        "post_tags": "</b>", # 标签前缀
        "fields":{  
            "name":{}  # 要设置高亮的字段属性 （查询里面的name）
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-udcHQ1Nn-1625810319953)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704011947629.png)]

关于索引的API操作

新建elasticsearchconfig包创建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;
    }
}

测试API

client.indices() 代表索引库

创建索引

@Resource
private RestHighLevelClient restHighLevelClient;

void testCreateIndex()
{
    // 1.创建索引请求
    CreateIndexRequest request = new CreateIndexRequest("lyc_index")
    //2. 客户端执行请求
    // client.indices() 会返回一个 IndicesClient 对象 通过这个对象去create 执行请求   请求后得到响应 CreateIndexResponse
    CreateIndexResponse createIndexResponse = client.indices().create(request,RequestOptions.DEFAULT);
}

获取索引

void testExistIndex() throws IOException
{
    // 创建索引请求 获取索引的api 
    GetIndexRequest request = new GetIndexRequest("lyc_index");
    // 调用exists方法 判断是否存在 返回bool类型
    Boolean exists = client.indices().exists(request,RequestOptions.DEFAULT);
    System.out.print(exists)
}

删除索引

void testDeleteIndex()
{
    // 创建索引请求
    DeleteIndexRequest delete = new DeleteIndexRequest("lyc_index");
    // 调用client.indices()索引库的delete()进行索引删除
   AcknowledgedResponse delete = client.indices().delete(request,RequestOption.DEFAULT);
    //  返回true则代表删除成功
    System.out.print(delete.isAcknowledged())
}

这个AcknowledgedResponse 就表示下面这个在elasticSearch-head 可以看到

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rVp51gsU-1625810319954)(C:\Users\edp06\AppData\Roaming\Typora\typora-user-images\image-20210704142837590.png)]

关于文档的操作（文档即一条条的数据）

新增文档

//创建实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private Integer age;
}

void testAddDocument() thows IOException
{
    // 创建对象
    User user = new User("lyc",2);
    // 创建请求
    IndexRequest request = new IndexRequest("lyc_index");
    
    // 规则  在kibana上 命令：PUT /lyc_index/_doc/1
    request.id("1")
    request.timout(TimeValue.timeValueSeconds(1)); // 超时 或者 request.timout("1s")
    // 将数据放入请求 json 
    // 需要引入 fastjson依赖 将对象转为json
    request.source(JSON.toJSONString(user),XContentType.JSON);
    // 客户端发送请求  获取响应结果
    IndexResponse  indexResponse =   client.index(request,RequestOptions.DEFAULT);
    
    System.out.print(indexResponse.toString) // 查看返回的信息
    System.out.print(indexResponse.status)  // 查看状态 返回 create
}

批量插入文档(bulk)

void testRequest() throws IOException 
{
   BulkRequest bulkRequest =  new BulkRequest();
    // 设置超时时间 这里可以 根据实际情况 设置大点 
   bulkRequest.time("10s");
    // 创建list集合 往里面添加数据
    ArrayList<User> userList = new ArrayList<>();
    userList.add(new User("lyc123",4));
     userList.add(new User("lyc124",4));
     userList.add(new User("lyc125",4));
     userList.add(new User("lyc323",4));
     userList.add(new User("lyc223",4));
    // 批处理请求
    for ( int i = 0 ; i < userList.size(); i++)
    {
        //  批量更新和删除 就在这里操作 修改请求就ok
        bulkRequest.add(
        new IndexRequest("lyc_index")
            .id(""+(i+1))   // 设置文档id （也就是数据id） 若不设置  则默认生成随机id
            .source(JSON.toJSONString(userList.get(i),XContentType.JSON)
        );
    }
        // 客户端发起请求
        BulkResponse bulkResponse = client.bulk(bulkRequest,RequestOptions.DEFAULT);
        System.out.print(bulkResponse.hasFailures()) ; // 是否失败 返回false 代表成功
}

获取文档

一般为了提高效率先判断是否存在

判断是否存在

void testIsExists() throws IOException
{
  //  创建索引请求
  GetRequest getRequest = new GetRequest("lyc_index","1");
  // 不获取返回的 _source 上下文
  getRequest.fetchSourceContext(new FetchSourceContext(false));
  getRequest.storeFields("_none_");  
  
  boolean exists = client.exists(getRequest,RequestOptions.DEFAULT);
    // 输出查看结果
   System.out.print(exists)  
}

获取文档信息

void testGetDocument() throws IOException
{
    // 创建索引请求 获取文档的api
    GetRequest getRequest = new GetRequest("lyc_index","1")
    // 客户端发送请求  执行
    GetResponse getResponse = client.get(getRequest,RequestOptions.DEFAULT);
    // 打印文档内容 只打印 _source 的信息
    System.out.print(getResponse.getSourceAsString());  
    //  返回全部的信息 和在kibana上命令查询操作一样
    System.out.print(getResponse); 
}

更新文档信息

void testUpdateDocument() throws IOException
{
    //创建索引请求 获取文档api
    UpdateRequest updateRequest = new UpdateRequest("lyc_index","1");
    // 设置请求超时时间
    updateRequest.timeout("1s")
    // 封装要求改的实体信息
    User user = new User("lyc12","1")
    updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
    
    // 客户端发送请求
    UpdateResponse updateResponse =  client.update(updateRequest,UpdateRequestOption.DEFAULT);
    System.out.print(updateResponse.status);  // 成功则返回 ok
}

删除文档

// 创建索引请求 获取索引api
DeleteRequest deleteRequest = new DeleteRequest("lyc_index","1");
// 设置超时时间
deleteRequest.timeout("1s");
//客户端发起请求
DeleteRespone deleteRespones = client.delete(deleteRequest,RequestOptions.DEFAULT);
System.out.print(deleteRespones.status);  // 成功则返回 ok

查询（重点）

SarchRequest 搜索请求
SearchSourceBuilder 条件构造
HighlightBuilder 构建高亮
TermQueryBuilder 精准查询
MatchAllQueryBuilder 匹配所有
xxx QueryBuilder 对应所有的命令

void testSearch()
{
    // 构建搜索请求
    SearchRequest searchRequest = new SearchRequest("lyc_index");
    
    // 构建搜索条件  比如 高亮搜索 排序 分页...
    SearchSourceBuilder sourceBuilder =   new SearchSourceBuilder();
    
    //  查询条件 构建查询构造器  也可以使用QueryBuilders工具类来实现 里面封装了很多查询条件的方法
    //  QueryBuilders 等同于 QueryBuilders queryBuilder =  new QueryBuilders();

    //  用来分页 一般用两个方法 匹配所有或者精确查询
    // termQuery 精准查询（倒排索引） term 查询是直接通过倒排索引指定的词条进行精确查找的
     TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name","lyc1212");  
    
    // MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery()  匹配所有
    
    sourceBuilder.query(termQueryBuilder);
    
    //设置分页  有默认参数 可以不写
    //sourceBuilder.from()     // 从哪里开始
    //sourceBuilder.size()     // 显示多少条数据
   
     // 设置超时时间
    sourceBuilder.timeout(new TimeValue(60,TimeUnit.SECONDS)); // 等同于 timeout(60)
    
     // 构建完查询条件之后 放到 searchRequest 构建搜索
    searchRequest.source(sourceBuilder);
    // 客户端执行请求
    SearchResponse searchResponse =  client.search(searchRequest,RequestOptions.DEFAULT);
    // 响应结果 都封装在searchResponse.gethits(返回值类型SearchHit对象)里面 拿数据要从这里面拿
    System.out.print(JSON.toJSONString(searchResponse.getHits())); // 因为是一个对象 所以需要转一下
    System.out.print("===============================================")
    // 对结果进行遍历
    for (SearchHit documentFields : searchResponse.getHits().getHits())
    {
       System.out.print(documentFields.getSourceAsMap()) // 打印全部
    }
}

显示多少条数据

 // 设置超时时间
sourceBuilder.timeout(new TimeValue(60,TimeUnit.SECONDS)); // 等同于 timeout(60)

 // 构建完查询条件之后 放到 searchRequest 构建搜索
searchRequest.source(sourceBuilder);
// 客户端执行请求
SearchResponse searchResponse =  client.search(searchRequest,RequestOptions.DEFAULT);
// 响应结果 都封装在searchResponse.gethits(返回值类型SearchHit对象)里面 拿数据要从这里面拿
System.out.print(JSON.toJSONString(searchResponse.getHits())); // 因为是一个对象 所以需要转一下
System.out.print("===============================================")
// 对结果进行遍历
for (SearchHit documentFields : searchResponse.getHits().getHits())
{
   System.out.print(documentFields.getSourceAsMap()) // 打印全部
}

}

曾是惊鸿照影来`

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ElaticSearch学习笔记

ElasticSearch学习笔记了解一个人：Doung Cutting 美国工程师 Lucence Nutch Hadoop都是出自他手被称为 hadoop 之父ElasticSearch 是 Shay Banon 基于Lucene 开发的开发了他第一个开源项目 compass 最后叫做 ElasticSearchLucence 是一套信息检索工具包 jar包不包含搜索引擎系统包含的：索引结构读写索引的工具排序搜索规则工具类Lucene和ElasticSearch关系
复制链接

扫一扫