ElaticSearch学习笔记

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核心概念

  1. 索引
  2. 字段类型(mapping【映射】)
  3. 文档(documents)
  4. 分片(倒排索引)

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
termdoc_1doc_2
study
everydayx

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

termdoc_1doc_2
study
everydayx
total21

优先去权重(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
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值