ElasticSearch,docker 安装ElasticSearch,Springboot 使用 ElasticSearch JavaAPI

什么是 ElasticSearch ?

数据库查询存在的问题：
性能低：使用模糊查询，左边有通配符，不会走索引，会全表扫描，性能低
关键字模糊查询比较麻烦

ElasticSearch概念

• ElasticSearch是一个基于Lucene的搜索服务器
• 是一个分布式、高扩展、高实时的搜索与数据分析引擎
• 基于RESTful web接口
• Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎
• 官网：https://www.elastic.co/

应用场景
• 搜索：海量数据的查询
• 日志数据分析
• 实时数据分析

ElasticSearch与MySql分工

• MySQL有事务性,而ElasticSearch没有事务性,所以你删了的数据是无法恢复的。
• ElasticSearch没有物理外键这个特性，,如果你的数据强一致性要求比较高,还是建议慎用

ElasticSearch和MySql分工不同，MySQL负责存储数据，ElasticSearch负责搜索数据。

ElasticSearch 核心概念

⚫ 索引（index）
ElasticSearch存储数据的地方，可以理解成关系型数据库中的数据库概念。
⚫ 映射（mapping）
mapping定义了每个字段的类型、字段所使用的分词器等。相当于关系型数据库中的表结构。
⚫ 文档（document）
Elasticsearch中的最小数据单元，常以json格式显示。一个document相当于关系型数据库中的一行数据。
⚫ 倒排索引
一个倒排索引由文档中所有不重复词的列表构成，对于其中每个词，对应一个包含它的文档id列表。
⚫ 类型（type）
一种type就像一类表。如用户表、角色表等。在Elasticsearch7.X默认type为_doc

• ES 5.x中一个index可以有多种type。
• ES 6.x中一个index只能有一种type。
• ES 7.x以后，将逐步移除type这个概念，现在的操作已经不再使用，默认_doc

RESTful风格

• REST（Representational State Transfer），表述性状态转移，是一组架构约束条件和原则。满足这些约束条件和
原则的应用程序或设计就是RESTful。就是一种定义接口的规范。
• 基于HTTP。
• 可以使用XML格式定义或JSON格式定义。
• 每一个URI代表1种资源。
• 客户端使用GET、POST、PUT、DELETE 4个表示操作方式的动词对服务端资源进行操作：
• GET：用来获取资源
• POST：用来新建资源（也可以用于更新资源）
• PUT：用来更新资源
• DELETE：用来删除资源

docker安装ElasticSearch

# 拉取elasticsearch镜像
docker pull elasticsearch:7.6.2
# 启动容器
docker run -d -e ES_JAVA_POTS="-Xms512m -Xmx512m" --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 然后docker ps -a 查看启动成功没有,logs查看日志  等待一会 去浏览器访问一下9200 启动时间有点久,多等一会儿

# 拉取kibana镜像
docker pull kibana:7.6.2
# 启动容器
docker run -d -p 5601:5601 --name=kibana --link elasticsearch -e "ELASTICSEARCH_URL=http://es安装的ip:9200" kibana:7.6.2

# 然后查看容器,等待一会儿刷新一下  5601去看看 多等一会 ps -a 看容器启动成功没有  多刷新



#Kibana在6.7以后的版本，支持了多种语言。并且自带在安装包里。修改方式如下：

# 修改中文
docker exec -it kibana /bin/bash
cd config
vi kibana.yml　　

#在kibana.yml配置文件中新增一行：


i18n.locale: "zh-CN"　　


# 安装ik	
docker exec -it elasticsearch /bin/bash

# 之后从github上抓取ik分词器的压缩包： 也可以复制在浏览器中下载后 docker cp 到容器指定的目录中

https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.6.2/elasticsearch-analysis-ik-7.6.2.zip




# 之后再plugins下建立ik文件夹将压缩包解压进入此文件夹：


cd plugins/
mv ../elasticsearch-analysis-ik-7.6.2.zip ./ik/
unzip elasticsearch-analysis-ik-7.6.2.zip

之后编辑plugin-descriptor.properties文件

vi plugin-descriptor.properties

# 在文件最后一行添加这行(打开发现有这一行,就不用添加)
elasticsearch.version=7.6.2

操作 ElasticSearch

操作索引

在Kibana中操作

# 添加索引
PUT xiaofu_index

# 查询多个索引
GET goods_index,xiaofu_index

# 查询所有索引
GET _all

# 删除索引
DELETE xiaofu

操作映射

操作文档

分词器

• 分词器（Analyzer）：将一段文本，按照一定逻辑，分析成多个词语的一种工具
如：华为手机 — > 华为、手、手机
• ElasticSearch 内置分词器
• Standard Analyzer - 默认分词器，按词切分，小写处理
• Simple Analyzer - 按照非字母切分(符号被过滤), 小写处理
• Stop Analyzer - 小写处理，停用词过滤(the,a,is)
• Whitespace Analyzer - 按照空格切分，不转小写
• Keyword Analyzer - 不分词，直接将输入当作输出
• Patter Analyzer - 正则表达式，默认\W+(非字符分割)
• Language - 提供了30多种常见语言的分词器
• ElasticSearch 内置分词器对中文很不友好，处理方式为：一个字一个词

IK分词器

• IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包
• 是一个基于Maven构建的项目
• 具有60万字/秒的高速处理能力
• 支持用户词典扩展定义
• 下载地址：https://github.com/medcl/elasticsearch-analysis-ik/archive/v7.6.2.zip

查询文档

• 词条查询：term
• 词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索
• 全文查询：match
• 全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

kibana 测试

# 添加映射
PUT user/_mapping
{
  "properties":{
    "name":{
      "type":"text"
    },
    "age":{
      "type":"integer"
    }
  }
}

# 创建索引
PUT person

# 添加映射
PUT person/_mapping
{
  "properties":{
    "name":{
      "type":"keyword"
    }
  }
}

# 查询映射
GET user/_mapping
GET person/_mapping


# 添加文档

#1.添加文档,指定ID
PUT user/_doc/1
{
  "name":"小付",
  "age":18,
  "address":"重庆"
}


#2.添加文档,不指定ID ,会默认给ID
POST user/_doc
{
    "name":"小花",
  "age":18,
  "address":"四川"
}


# 查询文档根据id
GET user/_doc/1

# 查询文档使用默认生成的ID
GET user/_doc/Ch9dWHQB3VMI6Uwz9joI

# 修改文档,id有就修改,没有就添加
PUT user/_doc/1
{
  "name":"小付",
  "age":18,
  "address":"重庆"
}

# 查询所有文档
GET user/_search

# 删除文档 根据ID
DELETE user/_doc/2




# 安装ik后测试中文分词器 细粒度
GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "我爱北京天安门"
}

# 粗粒度
GET _analyze
{
  "analyzer": "ik_smart",
  "text": "我爱北京天安门"
}


# 使用脚本
# 查询文档

# 查询所有
GET user/_search

# 添加一条
PUT user/_doc/3
{
    "name":"小甜",
  "age":18,
  "address":"华为5G手机"
}


# term 词条查询,查询的条件字符串和词条完全匹配
# es默认使用的分词器是standard 分词效果是一个字一个词
# 所以我们下面这个查询不到
GET user/_search
{
  "query": {
    "term": {
      "address": {
        "value": "重庆"
      }
    }
  }
}


# 从新创建索引添加映射 指定ik分词器 
# analyzer 指定分词器
# search_analyzer 指定搜索时的分词器
PUT phone
{
  "mappings": {
    "properties": {
      "name":{
        "type": "keyword"
      },
      "address":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

Springboot 使用 ElasticSearch JavaAPI(注释为详细解释)

springboot 导入 ElasticSearch JavaAPI 包

<!--        导入了elasticsearch-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

ElasticSearch 整合其余的项目

        <!--引入es的坐标-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.6.2</version>
        </dependency>

ESConfig

将 RestHighLevelClient 连接对象注入到IOC中

package com.fs.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//elasticsearch配置
@Configuration
public class ESConfig {

    @Value("${es.host}")
    private String host;
    @Value("${es.port}")
    private Integer port;

    //创建RestHighLevelClient交给springIOC容器
    @Bean
    public RestHighLevelClient getRestHighLevelClient(){
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost(host,port,"http")));
        return restHighLevelClient;
    }
}

StudyEsApiApplicationTests 测试类

/*
es 7.6.2 高级客户端测试
 */
@SpringBootTest
class StudyEsApiApplicationTests {

    //注入es客户端
    @Autowired
    @Qualifier("getRestHighLevelClient")
    private RestHighLevelClient restHighLevelClient;

    //注入goods
    @Autowired
    private GoodsMapper goodsMapper;
//.... 测试方法在后面
}

测试操作索引

• 添加索引
• 查询索引
• 删除索引
• 判断索引是否存

    //测试索引创建 所以的都是request
    @Test
    void testIndex() throws IOException {
        //创建索引的请求 使用CreateIndexRequest 构造方法传递一个字符串 索引名
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("xiaofu_index");
        //执行请求,使用es客户端来执行
        IndicesClient indices = restHighLevelClient.indices();
        //客户端执行请求,请求后获得响应,第二个参数使用默认的RequestOptions.DEFAULT
        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
        //成功返回true
        System.out.println(createIndexResponse.isAcknowledged());
    }


    //测试索引创建 所以的都是request,设置,mapping映射
    @Test
    void testIndexAndMapping() throws IOException {
        //创建索引的请求 使用CreateIndexRequest 构造方法传递一个字符串 索引名
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("xiaofu_index");
        //设置映射信息(使用json工具写好了后粘贴过来)
        String mapping = "{\n" +
                "      \"properties\" : {\n" +
                "        \"address\" : {\n" +
                "          \"type\" : \"text\",\n" +
                "          \"analyzer\" : \"ik_max_word\"\n" +
                "        },\n" +
                "        \"age\" : {\n" +
                "          \"type\" : \"long\"\n" +
                "        },\n" +
                "        \"name\" : {\n" +
                "          \"type\" : \"keyword\"\n" +
                "        }\n" +
                "      }\n" +
                "    }";
        //设置映射,指定为json
        createIndexRequest.mapping(mapping, XContentType.JSON);

        //执行请求,使用es客户端来执行
        IndicesClient indices = restHighLevelClient.indices();
        //客户端执行请求,请求后获得响应,第二个参数使用默认的RequestOptions.DEFAULT
        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
        //成功返回true
        System.out.println(createIndexResponse.isAcknowledged());
    }


    //测试获取索引
    @Test
    void testGetIndex() throws IOException {
        //创建获得索引请求,构造方法传递字符串的索引名称
        GetIndexRequest getIndexRequest = new GetIndexRequest("xiaofu_index");
        //使用客户端获取索引目录
        IndicesClient indices = restHighLevelClient.indices();

        //返回的布尔值就说明存不存在这个索引
        boolean exists = indices.exists(getIndexRequest, RequestOptions.DEFAULT);
        //获取映射信息
        GetIndexResponse getIndexResponse = indices.get(getIndexRequest, RequestOptions.DEFAULT);
        Map<String, MappingMetaData> mappings = getIndexResponse.getMappings();
        for (String s : mappings.keySet()) {
            MappingMetaData mappingMetaData = mappings.get(s);
            String type = mappingMetaData.type();
            System.out.println(s + "..." + type);
        }


        if (exists) {
            System.out.println(exists);
        } else {
            System.out.println("您的搜索有误");
        }
    }

    //测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        //获取删除请求,传递删除的索引名称
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("xiaofu_index");
        //使用客户端获取索引目录
        IndicesClient indices = restHighLevelClient.indices();
        //执行请求
        AcknowledgedResponse delete = indices.delete(deleteIndexRequest, RequestOptions.DEFAULT);

        //获取删除状态
        boolean acknowledged = delete.isAcknowledged();
        if (acknowledged) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败,不存在");
        }
    }

测试操作文档

• 添加文档
• 修改文档
• 根据id查询文档
• 删除文档

    //测试添加文档
    @Test
    void testAddDocument() throws IOException {
        //创建添加的对象
        User user = new User("小付", 18);

        //创建请求
        IndexRequest request = new IndexRequest("xiaofu_index");

        //规则 put/xiaofu_index/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));

        //将我们数据放入请求  使用jackson转换我们的User对象成json
        request.source(new ObjectMapper().writeValueAsString(user), XContentType.JSON);

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

        System.out.println(index.toString());
        System.out.println(index.status());//对应的命令返回状态OK
    }

    //获取文档测试,判断文档是否存在
    @Test
    void testIsExists() throws IOException {
        //获取get请求
        GetRequest getRequest = new GetRequest("xiaofu_index", "1");
        //不获取返回的 _source 的上下文
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        //
        getRequest.storedFields("_none_");

        //判断是否存在
        boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
        //获取对象
        if (exists) {
            System.out.println(exists);
        }
    }


    //获取文档的信息
    @Test
    void testGetDocument() throws IOException {
        //获取get请求
        GetRequest getRequest = new GetRequest("xiaofu_index", "1");
        //getRequest.id("1");
        //获取响应
        GetResponse documentFields = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        //获取Json的文档信息
        String sourceAsString = documentFields.getSourceAsString();
        System.out.println(sourceAsString);//文档值
        System.out.println(documentFields);//文档的所有信息
    }

    //更新文档的信息,添加文档时,如果id存在修改,不存在就添加
    @Test
    void testGetUpdateDocument() throws IOException {
        //获取更新请求
        UpdateRequest updateRequest = new UpdateRequest("xiaofu_index", "1");

        User user = new User("小付", 25);
        //更新,传递json
        updateRequest.doc(new ObjectMapper().writeValueAsString(user), XContentType.JSON);

        //发送更新请求
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);

        //输出执行响应结果
        System.out.println(updateResponse.status());//ok
        System.out.println(updateResponse.getId());//1
    }

    //删除文档的信息
    @Test
    void testDeleteDocument() throws IOException {
        //获取更新请求
        DeleteRequest deleteRequest = new DeleteRequest("xiaofu_index", "1");

        //deleteRequest.id("1");

        //发送删除请求,获取删除后的响应
        DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);

        //输出执行结果
        System.out.println(deleteResponse.status());//ok
        System.out.println(deleteResponse.getId());//1
    }

对应kibana的操作

# 添加文档
PUT phone/_doc/1
{
  "name":"小甜",
  "age":18,
  "address":"小米5G手机"
}

PUT phone/_doc/2
{
  "name":"小米",
  "age":18,
  "address":"华为5G手机"
}

PUT phone/_doc/3
{
  "name":"小付",
  "age":18,
  "address":"小米4G手机"
}

PUT phone/_doc/4
{
  "name":"小付",
  "age":18,
  "address":"重庆"
}


# 查询所有
GET phone/_search

# term 词条查询 词条完全匹配
GET phone/_search
{
  "query": {
    "term": {
      "address": {
        "value": "重庆"
      }
    }
  }
}

# match 先回对查询的字符串进行分词,在查询,求并集

GET phone/_search
{
  "query": {
    "match": {
      "address": "华为手机"
    }
  }
}


# 查询映射
GET xiaofu_index/_mapping

# 查询所有
GET xiaofu_index/_search

批量操作-脚本

GET phone/_search

# 批量操作-脚本
# 删除4号记录
# 添加8号记录
# 修改2号记录名称为红米
POST _bulk
{"delete":{"_index":"phone","_id":"4"}}
{"create":{"_index":"phone","_id":"8"}}
{"name":"呵呵","age":58,"address":"重庆"}
{"update":{"_index":"phone","_id":"2"}}
{"doc":{"name":"红米"}}

批量操作-JavaAPI

    //大量插入数据
    @Test
    void testBulkRequest() throws IOException {
        //创建大批量请求,整合所有的请求操作的
        BulkRequest bulkRequest = new BulkRequest();
        User user = new User("小花", 8);
        User user2 = new User("小离", 8);
        User user3 = new User("小昂", 8);
        User user4 = new User("小✿", 9);
        ArrayList<User> users = new ArrayList<>();
        users.add(user4);
        users.add(user3);
        users.add(user2);
        users.add(user);

        //遍历集合,循环插入到bulkRequest中
        for (int i = 0; i < users.size(); i++) {
            //循环插入,使用链式编程
            bulkRequest.add(new IndexRequest("xiaofu_index").id("" + (i + 1)).source(new ObjectMapper().writeValueAsString(users.get(i)), XContentType.JSON));
        }

        //发送请求
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.status());//ok
    }

    //批量对文档进行增删改
    @Test
    void testBulkRequest02() throws IOException {
        /*
        # 批量操作-脚本
        # 删除3号记录
        # 添加8号记录
        # 修改2号记录名称为红米
         */
        //创建大批量请求,整合所有的请求操作的
        BulkRequest bulkRequest = new BulkRequest();

        //删除3号记录
        //添加6号记录
        //修改2号记录名称为小米

        HashMap<String, Object> map6 = new HashMap<>();
        map6.put("name","六号");

        HashMap<String, Object> map2 = new HashMap<>();
        map2.put("name","小米");
        //执行批量操作(传递json)  使用链式编程
        bulkRequest.add(new DeleteRequest("phone","3"))//删除3号记录
                .add(new IndexRequest("phone").id("6").source(new ObjectMapper().writeValueAsString(map6),XContentType.JSON))//添加8号记录
                .add(new UpdateRequest("phone","2").doc(new ObjectMapper().writeValueAsString(map2),XContentType.JSON));//修改2号记录名称为USer小米


        //执行批量操作(传递map)  使用链式编程
//        bulkRequest.add(new DeleteRequest("phone","3"))
//                .add(new IndexRequest("phone").id("6").source(map6))
//                .add(new UpdateRequest("phone","2").doc(map2));

        //发送请求
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        System.out.println(bulk.status());//ok
    }


    //批量从数据库中添加数据

    @Test
    void testBulkRequest03() throws IOException {

        //创建大批量请求,整合所有的请求操作的
        BulkRequest bulkRequest = new BulkRequest();

        //使用MyBatis-plus 查询的
        //查询数据库中的所有goods信息
        List<Goods> goods = goodsMapper.selectList(null);
//        //分页查询需要这个类,我们就new出来,传递当前页与每页条数
//        Page<Goods> goodsPage = new Page<>(1,10);
//
//        //Wrapper 没有就给null
//        Page<Goods> goodsPages = goodsMapper.selectPage(goodsPage, null);
//
//        List<Goods> goods = goodsPages.getRecords();

        //遍历
        for (Goods good : goods) {
            //将字符串转成map
//            Map map = new ObjectMapper().readValue(good.getSpec(), Map.class);
//            good.setSpecMap(map);

            bulkRequest.add(new IndexRequest("goods").id(good.getId()+"").source(new ObjectMapper().writeValueAsString(good),XContentType.JSON));

        }

        //发送请求
        BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        System.out.println(bulk.status());//ok
    }

matchAll查询-脚本

测试这个需要先准备大量数据

# 查询所有goods

GET goods/_search

GET goods


# matchALL查询-脚本
GET goods/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 20
}

matchAll查询-JavaAPI

 /**
     * 查询所有
     *  1. matchAll
     *  2. 将查询结果封装为Goods对象，装载到List中
     *  3. 分页。默认显示10条
     */
    @Test
    public void testMatchAll() throws IOException {
        //创建查询请求对象,指定查询的索引名称
        SearchRequest searchRequest = new SearchRequest("goods");
        //创建查询条件构造器
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //指定查询条件,查询条件是使用条件构造器制作的 QueryBuilders.matchAllQuery() 查询所有文档
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置查询的条件

        //添加分页信息,指定查询100条数据
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(100);

        //添加查询条件构建器 SearchSourceBuilder
        searchRequest.source(searchSourceBuilder);

        //查询,获取查询结果
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);


        // 获取命中对象 SearchHits
        SearchHits responseHits = searchResponse.getHits();
        //获取总条数
        long value = responseHits.getTotalHits().value;
        System.out.println("总记录数:"+value);

        //获取Hits数据  数组
        SearchHit[] hits = responseHits.getHits();

        //创建一个数组来存储我们查询出的json数据
        ArrayList<Goods> goodsArrayList = new ArrayList<>();

        for (SearchHit hit : hits) {
            //获取查询出的数据的json对象
            String sourceAsString = hit.getSourceAsString();
            //转成goods对象
            Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);
            //添加
            goodsArrayList.add(goods);
        }

        //遍历输出一下
        for (Goods goods : goodsArrayList) {
            System.out.println(goods);
        }
    }

term查询-脚本

# term查询 不会对查询条件进行分词,完全匹配才能查出来
GET goods/_search
{
  "query": {
    "term": {
      "title": {
        "value": "华为"
      }
    }
  }
}

term查询-JavaAPI

    //查询 term查询：不会对查询条件进行分词。
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");

        //构建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //使用QueryBuilders工具类  term 精确匹配
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "小米");
//        QueryBuilders.matchQuery() 匹配所有

        SearchSourceBuilder query = searchSourceBuilder.query(termQueryBuilder);

        //指定查询条件,查询条件是使用条件构造器制作的
        searchRequest.source(query);

        //发送
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //查询结果
        System.out.println(new ObjectMapper().writeValueAsString(search.getHits()));

        System.out.println("================");

        for (SearchHit hit : search.getHits().getHits()) {

            System.out.println(hit.getSourceAsMap());
        }
    }

match查询-脚本

# match查询
#• 会对查询条件进行分词。
#• 然后将分词后的查询条件和词条进行等值匹配
#• 默认取并集（OR）

# 使用match查询出华为手机
GET goods/_search
{
  "query": {
    "match": {
      "title": "华为手机"
    }
  }
}

# 默认取并集（OR）
GET goods/_search
{
  "query": {
    "match": {
      "title": {
        "query": "华为手机",
        "operator": "and"
      }
    }
  }
}

match查询-JavaAPI

    /**
     * matchQuery:词条分词查询
     */
    @Test
    public void testMatchQuery() throws IOException {

        //创建查询请求
        SearchRequest searchRequest = new SearchRequest("goods");

        //创建查询条件构造器
        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();

        //设置查询的参数  使用链式编程设置参数 operator(Operator.AND)//求并集
        sourceBulider.query(QueryBuilders.matchQuery("title","华为手机").operator(Operator.AND));

        //将查询条件构造交给查询请求对象
        searchRequest.source(sourceBulider);

        //设置返回的分页数
        sourceBulider.from(0);
        sourceBulider.size(20);

        //发送查询请求
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //获取查询出的结果
        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);

            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

模糊查询-脚本

wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
regexp查询：正则查询
prefix查询：前缀查询

# 模糊匹配
#wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
# regexp查询：正则查询
# prefix查询：前缀查询
GET goods/_search
{
  "query": {
    "wildcard": {
      "title": {
        "value": "华?"
      }
    }
  }
}

# 正则
GET goods/_search
{
  "query": {
    "regexp": {
      "title": "\\w+(.)*"
    }
  }
}

# 前缀查询
GET goods/_search
{
  "query": {
    "prefix": {
      "brandName": {
        "value": "金"
      }
    }
  }
}

模糊查询-JavaAPI

       /**
     * 模糊查询:WildcardQuery
     */
    @Test
    public void testWildcardQuery() throws IOException {


        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();

        //设置莫慌查询
        sourceBulider.query(QueryBuilders.wildcardQuery("title","华?"));

        searchRequest.source(sourceBulider);


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


        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);

            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }



    /**
     * 模糊查询:regexpQuery
     */
    @Test
    public void testRegexpQuery() throws IOException {


        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();

        //设置莫慌查询
        sourceBulider.query(QueryBuilders.regexpQuery("title","\\w+(.)*"));

        searchRequest.source(sourceBulider);


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


        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);

            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }



    /**
     * 模糊查询:perfixQuery
     */
    @Test
    public void testPrefixQuery() throws IOException {


        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();

//        PrefixQueryBuilder query = QueryBuilders.prefixQuery("brandName", "三");

        sourceBulider.query(QueryBuilders.prefixQuery("brandName","金"));

        searchRequest.source(sourceBulider);


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


        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods =new ObjectMapper().readValue(sourceAsString,Goods.class);
            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

范围查询-脚本

range 范围查询：查找指定字段在指定范围内包含值

# 范围查询 
# gt 大于 lt 小于
# gte 大于等于  lte 小于等于
# sort 排序

GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 1000,
        "lte": 2000
      }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

范围查询-JavaAPI

    /**
     * 1. 范围查询：rangeQuery
     * 2. 排序
     */
    @Test
    public void testRangeQuery() throws IOException {


        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();


//        //范围查询
//        RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
//
//        //指定下限
//        query.gte(2000);
//        //指定上限
//        query.lte(3000);

        //使用链式编程 设置范围查询
        sourceBulider.query(QueryBuilders.rangeQuery("price").gte(1000).lte(2000));

        //排序
        sourceBulider.sort("price", SortOrder.DESC);


        searchRequest.source(sourceBulider);


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


        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);
            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

queryString查询-脚本

queryString：
• 会对查询条件进行分词。
• 然后将分词后的查询条件和词条进行等值匹配
• 默认取并集（OR）
• 可以指定多个查询字段

# queryString：
#• 会对查询条件进行分词。
#• 然后将分词后的查询条件和词条进行等值匹配
#• 默认取并集（OR）
#• 可以指定多个查询字段
GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","categoryName","brandName"],
      "query": "华为 AND 手机"
    }
  }
}

queryString查询-JavaAPI

    /**
     * queryString
     */
    @Test
    public void testQueryStringQuery() throws IOException {


        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();


        //queryString
//        QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("华为手机")
//        .field("title").field("categoryName").field("brandName")
//        .defaultOperator(Operator.AND);


        //queryString 查询,默认使用OR并集  使用AND 查询分词交集
        sourceBulider.query(QueryBuilders.queryStringQuery("华为 AND 手机").field("title")
        .field("categoryName").field("brandName"));



        searchRequest.source(sourceBulider);


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


        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);

            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

布尔查询-脚本

boolQuery：对多个查询条件连接。连接方式：
• must（and）：条件必须成立
• must_not（not）：条件必须不成立
• should（or）：条件可以成立
• filter：条件必须成立，性能比must高。不会计算得分

# boolQuery：对多个查询条件连接。连接方式：
#• must（and）：条件必须成立
#• must_not（not）：条件必须不成立
#• should（or）：条件可以成立
#• filter：条件必须成立，性能比must高。不会计算得分


#  must（and）：条件必须成立
# 查询bardName为华为的和title包含手机的
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        },
        {
          "match": {
            "title": "手机"
          }
        }
      ]
    }
  }
}


GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "小米"
            }
          }
        }
      ],
      "filter": [
        {
          "term": {
            "title": "手机"
          }
        }
      ]
    }
  }
}


# filter：条件必须成立，性能比must高。不会计算得分
#      * 1. 查询品牌名称为:华为
#     * 2. 查询标题包含：手机
#     * 3. 查询价格在：2000-3000
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        },
        {
          "match": {
            "title": "手机"
          }
        }
      ],
      "filter": [
        {
          "range": {
            "price": {
              "gte": 2000,
              "lte": 3000
            }
          }
        }
      ]
    }
  }
}

布尔查询-JavaAPI

    /**
     * 布尔查询：boolQuery
     * 1. 查询品牌名称为:华为
     * 2. 查询标题包含：手机
     * 3. 查询价格在：2000-3000
     */
    @Test
    public void testBoolQuery() throws IOException {

        SearchRequest searchRequest = new SearchRequest("goods");

        SearchSourceBuilder sourceBulider = new SearchSourceBuilder();


        //1.构建boolQuery
//        BoolQueryBuilder query = QueryBuilders.boolQuery();
//
//        //2.构建各个查询条件
//        //2.1 查询品牌名称为:华为
//        QueryBuilder termQuery = QueryBuilders.termQuery("brandName","华为");
//        query.must(termQuery);
//
//        //2.2. 查询标题包含：手机
//        QueryBuilder matchQuery = QueryBuilders.matchQuery("title","手机");
//        query.filter(matchQuery);
//
//        //2.3 查询价格在：2000-3000
//        QueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
//        ((RangeQueryBuilder) rangeQuery).gte(2000);
//        ((RangeQueryBuilder) rangeQuery).lte(3000);
//        query.filter(rangeQuery);


        //3.使用boolQuery连接 链式编程
        sourceBulider.query(QueryBuilders.boolQuery().must(QueryBuilders.termQuery("brandName","华为"))
        .must(QueryBuilders.matchQuery("title","手机")).filter(QueryBuilders.rangeQuery("price").gte(2000).lte(3000)));

        searchRequest.source(sourceBulider);

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

        SearchHits searchHits = searchResponse.getHits();
        //获取记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数："+value);

        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();

            //转为java
            Goods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);
            goodsList.add(goods);
        }

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

聚合查询-脚本

• 指标聚合：相当于MySQL的聚合函数。max、min、avg、sum等
• 桶聚合：相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。

# 聚合函数 

# 指标聚合

# 查询包含华为的 最贵的手机
GET goods/_search
{
  "query": {
    "match": {
      "title": "华为"
    }
  },
  "aggs": {
    "NAME": {
      "max": {
        "field": "price"
      }
    }
  }
}


# 桶聚合 分组

# 查出title包含手机的 然后根据brandName 分组显示品牌
GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "aggs": {
    "NAME": {
      "terms": {
        "field": "brandName",
        "size": 100
      }
    }
  }
}

聚合查询-JavaAPI

    /**
     * 聚合查询：桶聚合，分组查询
     * 1. 查询title包含手机的数据
     * 2. 查询品牌列表
     */
    @Test
    public void testAggQuery() throws IOException {

        //创建查询请求对象
        SearchRequest searchRequest = new SearchRequest("goods");

        //构建查询对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //设置查询条件
        searchSourceBuilder.query(QueryBuilders.matchQuery("title","手机"));

        // 2. 查询品牌列表
        /*
        参数：
            1. 自定义的名称goods_brands，将来用于获取数据
            2. 分组的字段
         */

        searchSourceBuilder.aggregation(AggregationBuilders.terms("goods_brands")
                .field("brandName").size(100));

        //给查询请求传递构建对象
        searchRequest.source(searchSourceBuilder);

        //发送请求  得到响应对象
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //获取命中结果
        SearchHits hits = searchResponse.getHits();
        //获取总命中数
        long value = hits.getTotalHits().value;
        System.out.println("总记录数:"+value);

        //获取命中结果集合
        SearchHit[] hitsHits = hits.getHits();
        //创建一个集合来存储命中结果的每个对象
        ArrayList<Goods> goodsArrayList = new ArrayList<>();

        //遍历命中结果
        for (SearchHit hitsHit : hitsHits) {
            //获取每条命中结果的json字符串
            String sourceAsString = hitsHit.getSourceAsString();

            //转成对象
            Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);
            //添加到集合
            goodsArrayList.add(goods);
        }

        //遍历集合输出
        for (Goods goods : goodsArrayList) {
            System.out.println(goods);
        }

        System.out.println("-------------获取聚合结果-----------------");

        Aggregations aggregations = searchResponse.getAggregations();
        //获取结果map
        Map<String, Aggregation> asMap = aggregations.getAsMap();
        //获取聚合
        Terms goodsBrands = (Terms) asMap.get("goods_brands");

        //
        List<? extends Terms.Bucket> buckets = goodsBrands.getBuckets();

        //创建一个集合来存储分组后的数据
        ArrayList<Object> objects = new ArrayList<>();

        for (Terms.Bucket bucket : buckets) {
            Object key = bucket.getKey();
            objects.add(key);
        }

        //输出分组数据
        for (Object object : objects) {
            System.out.println(object);
        }
    }

高亮查询-脚本

高亮三要素：
• 高亮字段
• 前缀
• 后缀

# 高亮查询


GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "highlight": {
    "fields": {
      "title": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>"
        
      }
    }
  }
}

高亮查询-JavaAPI

    /**
     * 高亮查询：
     *  1. 设置高亮
     *      * 高亮字段
     *      * 前缀
     *      * 后缀
     *  2. 将高亮了的字段数据，替换原有数据
     */


    @Test
    public void testHighLightQuery() throws IOException {

        //创建查询请求
        SearchRequest searchRequest = new SearchRequest("goods");

        //创建查询条件构造器
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //查询title包含手机的数据
        searchSourceBuilder.query(QueryBuilders.matchQuery("title","手机"));

        //创建高亮构造,设置高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("title").preTags("<font color='red'>").postTags("</font>");

        //设置高亮
        searchSourceBuilder.highlighter(highlightBuilder);

        //设置条件
        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //获取命中结果
        SearchHits hits = search.getHits();

        //装Goods
        ArrayList<Goods> goodsArrayList = new ArrayList<>();

        //获取总记录数
        long value = hits.getTotalHits().value;
        System.out.println("总记录数:"+value);

        //遍历
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);

            goodsArrayList.add(goods);
        }

        //输出
        for (Goods goods : goodsArrayList) {
            System.out.println(goods);
        }
    }