Elasticsearch基础

news/2024/7/5 2:27:22

Elasticsearch是搜索服务器

视频地址：https://www.bilibili.com/video/BV1Sy4y1G7LL/?p=6&spm_id_from=333.880.my_history.page.click&vd_source=fc7fa697b97f292319c5b0cde4755484
下载地址：[https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.4.0-linux-x86_64.tar.gz

数据库搜索缺点](https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.4.0-linux-x86_64.tar.gz)

性能低

在这里插入图片描述

功能瑞

在这里插入图片描述

倒排索引

正向索引

在这里插入图片描述

初识倒排索引

在这里插入图片描述
优化：倒排索引将value修改为对应诗名或者id
在这里插入图片描述

Elasticsearch存储和搜索原理

在这里插入图片描述
在这里插入图片描述

Elasticsearch概念

在这里插入图片描述

Elasticsearch和Mysql的不同点

在这里插入图片描述

Elasticsearch下载部署

这里在本机玩，不介绍linux下集群部署
下载后
进入elasticsearch bin目录下
./elasticsearch -d 后台启动
mac电脑操作查看进程
jps 查看进程端口
sudo lsof -nP -p 进程号| grep LISTEN
linux查看端口
jps
netstat -nltp|grep elasticsearch`
在这里插入图片描述
默认配置为9200端口为http请求
9300断后为tcp elasticsearch内部通信
访问9200成功即为elasticsearch启动成功
在这里插入图片描述

Elasticsearch核心概念

索引，映射，文档
在这里插入图片描述

脚本操作ES

基于RESTful风格

操作索引

1.查看es安装成功

GET http://127.0.0.1:9200
在这里插入图片描述

2.添加索引

PUT http://127.0.0.1:9200/goods
在这里插入图片描述

3.查看指定索引信息及所有索引

GET http://127.0.0.1:9200/goods
在这里插入图片描述
GET http://127.0.0.1:9200/_all
在这里插入图片描述

4.删除指定索引

DELETE http://127.0.0.1:9200/goods2
在这里插入图片描述

5.关闭索引

POST http://127.0.0.1:9200/goods/_close
在这里插入图片描述

6.开启索引

POST http://127.0.0.1:9200/goods/_open
在这里插入图片描述

操作映射

简单数据类型

字符串：
在这里插入图片描述
数值：
在这里插入图片描述
布尔
在这里插入图片描述
二进制
在这里插入图片描述
范围类型
在这里插入图片描述
日期
在这里插入图片描述

复杂数据类型

数组
对象
在这里插入图片描述

添加映射

PUT http://127.0.0.1:9200/person/_mapping

{
    "properties":{
        "name":{
            "type":"keyword"
        },
        "age":{
            "type":"integer"
        }
    }
}

在这里插入图片描述

查询映射

GET http://127.0.0.1:9200/person/_mapping
在这里插入图片描述

添加索引的同时添加映射

PUT http://127.0.0.1:9200/person

{
    "mappings":{
    "properties":{
        "name":{
            "type":"keyword"
        },
        "age":{
            "type":"integer"
        }
    }
    }
}

在这里插入图片描述

添加字段

PUT http://127.0.0.1:9200/person/_mapping

{
    "properties":{
        "address":{
            "type":"text"
        }
    }
}

在这里插入图片描述

操作文档

添加文档

添加文档指定文档id

PUT http://127.0.0.1:9200/person/_doc/1

{
    "name":"张三",
    "age":20,
    "address":"北京"
}

在这里插入图片描述

添加文档不指定文档id

POST http://127.0.0.1:9200/person/_doc/

{
    "name":"李四",
    "age":18,
    "address":"朝阳"
}

在这里插入图片描述

查询文档

根据id查询文档

GET http://127.0.0.1:9200/person/_doc/8uh0bYgBAYb4xsq8VhGD
在这里插入图片描述

查询索引下的所有文档

PUT http://127.0.0.1:9200/person/_doc/_search
在这里插入图片描述

修改文档

PUT http://127.0.0.1:9200/person/_doc/1

{
    "name":"张飞",
    "age":20,
    "address":"北京"
}

在这里插入图片描述

删除文档

根据id删除文档

DELETE http://127.0.0.1:9200/person/_doc/1

在这里插入图片描述

分词器

es内置分词器对中文很不友好
在这里插入图片描述

测试

GET http://127.0.0.1:9200/_analyze

{
    "analyzer":"standard",
    "text":"我爱北京天安门"
}

在这里插入图片描述

下载ik分词器

ik分词器和es适配版本
在这里插入图片描述
这里用的es为7.17.10所以ik分词器下载地址为
https://github.com/medcl/elasticsearch-analysis-ik/releases/tag/v7.17.1
下载完后放入es的plugin目录下
在这里插入图片描述
将解压的elasticsearch-analysis-ik-7.17.1下的文件cp到plugin/analysis-ik下
cp -r /Users/hejiawang/elasticsearch-7.17.10/plugins/analysis-ik/elasticsearch-analysis-ik-7.17.1/* /Users/hejiawang/elasticsearch-7.17.10/plugins/analysis-ik
将ik分词器下的config文件copy到es的config目录下
cp -r /Users/hejiawang/elasticsearch-7.17.10/plugins/analysis-ik/elasticsearch-analysis-ik-7.17.1/config/* /Users/hejiawang/elasticsearch-7.17.10/config
在这里插入图片描述
在这里插入图片描述
重启es
启动es报错
在这里插入图片描述
vi /Users/hejiawang/elasticsearch-7.17.10/plugins/analysis-ik/plugin-descriptor.properties
将elasticsearch.version=7.17.1 改为elasticsearch.version=7.17.10
在这里插入图片描述
再次重启

使用ik分词器

ik_smart粗力度分词

GET http://127.0.0.1:9200/_analyze

{
    "analyzer":"ik_smart",
    "text":"我爱北京天安门"
}

在这里插入图片描述

ik_smart细力度分词

GET http://127.0.0.1:9200/_analyze

{
    "analyzer":"ik_max_word",
    "text":"我爱北京天安门"
}

在这里插入图片描述

查询文档

词条查询

词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索

全文查询

全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

Demo演示

指定索引查询所有数据 有一条数据
在这里插入图片描述
按词条查询文档
因为查询条件为北京，es默认address使用默认分词器，分词为北，京，朝，阳 无法匹配，除非创建mapping时候指定address映射为ik_max_word即可查到
GET http://127.0.0.1:9200/person/_search

{
    "query":{
        "term":{
            "address":{
                "value":"北京"
            }
        }
    }
}

在这里插入图片描述
全文查询
GET http://127.0.0.1:9200/person/_search

{
    "query":{
        "match":{
            "address": "北京"
        }
    }
}

在这里插入图片描述

JAVA操作ES

Springboot整合ES

创建Springboot项目

1.引入pom

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.17.1</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.17.1</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.17.1</version>
        </dependency>

2.创建自动装在配置类

package com.hejiawang.elasticsearch.config;

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

@Configuration
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticsearchConfig  {
    private String host;
    private int port;
    public void setHost(String host) {
        this.host = host;
    }

    public void setPort(int port) {
        this.port = port;
    }

    @Bean
    public RestHighLevelClient client(){
        return new RestHighLevelClient(RestClient.builder(new HttpHost(host,port,"http")));
    }
}

3.创建application.yml并且加上配置

elasticsearch:
  host: 127.0.0.1
  port: 9200

4.创建测试类

package com.hejiawang.elasticsearch;

import com.hejiawang.elasticsearch.config.ElasticsearchConfig;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ElasticsearchApplicationTests {
    @Autowired
    RestHighLevelClient client;
    @Test
    void contextLoads() {
//        1.创建es客户端对象
//        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200,"http")));
        System.out.println(client);
    }
}

javaAPI操作ES

添加索引

添加索引不指定mapping

    /*添加索引*/
    @Test
    public void addIndex() throws IOException {
//        1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
//        2.具体操作返回值
        CreateIndexRequest createRequest =  new CreateIndexRequest("test_hejiawang");
        CreateIndexResponse response = indices.create(createRequest, RequestOptions.DEFAULT);
//        3.根据返回值判断结果
        System.out.println(response.isAcknowledged());
    }

在这里插入图片描述

添加索引指定mapping

    /*添加索引*/
    @Test
    public void addIndex() throws IOException {
//        1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
//        2.具体操作返回值
        CreateIndexRequest createRequest =  new CreateIndexRequest("test_hejiawang2");
//        2.1设置mapping
        String mapping = "{\n" +
                "    \"properties\":{\n" +
                "        \"name\":{\n" +
                "            \"type\":\"keyword\"\n" +
                "        },\n" +
                "        \"age\":{\n" +
                "            \"type\":\"integer\"\n" +
                "        }\n" +
                "    }\n" +
                "}";
        createRequest.mapping(mapping, XContentType.JSON);
        CreateIndexResponse response = indices.create(createRequest, RequestOptions.DEFAULT);
//        3.根据返回值判断结果
        System.out.println(response.isAcknowledged());
    }

在这里插入图片描述

查询索引

    /*查询索引*/
    @Test
    public void queryIndex() throws IOException {
        //        1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
        GetIndexRequest getRequest = new GetIndexRequest("test_hejiawang2");
        GetIndexResponse response = indices.get(getRequest, RequestOptions.DEFAULT);
//        获取结果
        Map<String, MappingMetadata> mappings = response.getMappings();
        for (String key : mappings.keySet()){
            System.out.println(key+":"+mappings.get(key).getSourceAsMap());
        }
    }

在这里插入图片描述

删除索引

    /*删除索引*/
    @Test
    public void deleteIndex() throws IOException {
        //        1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
        DeleteIndexRequest deleteRequest = new DeleteIndexRequest("test_hejiawang2");
        AcknowledgedResponse response = indices.delete(deleteRequest, RequestOptions.DEFAULT);
//        3.根据返回值判断结果
        System.out.println(response.isAcknowledged());
    }

在这里插入图片描述

判断索引是否存在

    /*判断索引是否存在*/
    @Test
    public void existIndex() throws IOException {
        //        1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
        GetIndexRequest request = new GetIndexRequest("test_hejiawang2");
        boolean exists = indices.exists(request, RequestOptions.DEFAULT);
//        3.根据返回值判断结果
        System.out.println(exists);
    }

在这里插入图片描述

添加文档

添加文档使用map作为数据

    /*添加文档*/
    @Test
    public void addDoc() throws IOException {
//        1.获取操作文档的对象
        Map data = new HashMap<>();
        data.put("name","张三");
        data.put("age",18);
        IndexRequest request = new IndexRequest("test_hejiawang2").id("1").source(data);
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//        2.获取结果
        System.out.println(response.getId());
    }

在这里插入图片描述

添加文档使用对象作为数据

创建Person对象

    /*添加文档,使用对象作为数据*/
    @Test
    public void addDoc2() throws IOException {
//        1.获取操作文档的对象
        Person person = new Person();
        person.setName("王五");
        person.setAge(19);
//        将对象转为Json
        String data = JSON.toJSONString(person);
        IndexRequest request = new IndexRequest("test_hejiawang2").id("1").source(data,XContentType.JSON);
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//        2.获取结果
        System.out.println(response.getId());
    }

在这里插入图片描述

修改文档

    /*修改文档,如果id存在为添加文档，如果id不存在为修改文档*/
    @Test
    public void updateDoc() throws IOException {
//        1.获取操作文档的对象
        Person person = new Person();
        person.setName("王五");
        person.setAge(19);
//        将对象转为Json
        String data = JSON.toJSONString(person);
        IndexRequest request = new IndexRequest("test_hejiawang2").id("1").source(data,XContentType.JSON);
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//        2.获取结果
        System.out.println(response.getId());
    }

根据id查询文档

    /*根据id查询文档*/
    @Test
    public void findDocById() throws IOException {
         GetRequest request = new GetRequest("test_hejiawang2","1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
//        2.获取结果
        System.out.println(response.getSourceAsString());
    }

在这里插入图片描述

删除文档

    /*根据id删除文档*/
    @Test
    public void deleteDocById() throws IOException {
        DeleteRequest request = new DeleteRequest("test_hejiawang2", "1");
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
//        2.获取结果
        System.out.println(response.getId());
    }

在这里插入图片描述

ES高级操作

批量操作

批量操作api调用

在这里插入图片描述
批量增删改查
POST http://127.0.0.1:9200/_bulk
postmain中最后一定要有个空行，不然会报错

{"delete":{"_index":"test_hejiawang2","_id":"1"}}
{"create":{"_index":"test_hejiawang2","_id":"2"}}
{"name":"何佳旺","age":18}
{"update":{"_index":"test_hejiawang2","_id":"1"}}
{"doc":{"name":"zzz"}}

在这里插入图片描述

批量操作java代码

    @Test
    public void testBulk() throws IOException {
//        创建bulkrequest对象
        BulkRequest request = new BulkRequest();
//         添加操作
//        1.删除1号记录
        DeleteRequest deleteRequest = new DeleteRequest("test_hejiawang2","1");
        request.add(deleteRequest);
//        2.添加6号记录
        Map map = new HashMap<>();
        map.put("name","飞哥");
        IndexRequest indexRequest = new IndexRequest("test_hejiawang2").id("6").source(map);
        request.add(indexRequest);
//        3.修改6号记录
        Map map2 = new HashMap();
        map2.put("name","肥哥");
        UpdateRequest updateRequest = new UpdateRequest("test_hejiawang2","6").doc(map2);
        request.add(updateRequest);
//        添加操作
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        RestStatus status = response.status();
        System.out.println(status);
    }

在这里插入图片描述

导入数据

1.mysql创建表

CREATE TABLE goods(
    id bigint(20),
    title varchar(100),
    price decimal(20,2),
    stock int(10),
    saleNum int(10),
    creatTime dateTime,
    categoryName varchar(200),
    brandName varchar(100),
    spec varchar(200)
)

2.es创建索引

PUT http://127.0.0.1:9200/goods

{
    "mappings":{
        "properties":{
            "titles":{
                "type": "text",
                "analyzer":"ik_smart"
            },
            "price":{
                "type": "double"
            },
            "createTime":{
                "type": "date"
            },
            "categoryName":{
                "type": "keyword"
            },
            "brandName":{
                "type": "keyword"
            },
            "spec":{
                "type": "object"
            },
            "saleNum":{
                "type": "integer"
            },
            "stock":{
                "type": "integer"
            }
        }
    }
}

3.在数据库中准备数据数据

insert into 3309test.goods (`id`, `title`, `price`, `stock`, `saleNum`, `creatTime`, `categoryName`, `brandName`, `spec`) values (1, '华为5G', 2399, null, 38, NOW() , '手机', '华为', '{"机身内存":"16g","网络":"联通2G"}');
insert into 3309test.goods (`id`, `title`, `price`, `stock`, `saleNum`, `creatTime`, `categoryName`, `brandName`, `spec`) values (2, '苹果 1', 2399, null, 38, NOW() , '手机', '苹果', '{"机身内存":"16g","网络":"联通2G"}');

4.引入相关依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.4</version>
        </dependency>
                <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

5.准备domain

package com.hejiawang.elasticsearch.domain;

import com.alibaba.fastjson.annotation.JSONField;

import java.util.Date;
import java.util.Map;

public class Goods {
    private int id;
    private String title;
    private double price;
    private int stock;
    private int saleNum;
    private Date creatTime;
    private String categoryName;
    private String brandName;
    private Map spec;
    @JSONField(serialize = false) //在转换JSON时忽略该字段
    private String specStr; //接受数据库的信息"{}"

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    public int getSaleNum() {
        return saleNum;
    }

    public void setSaleNum(int saleNum) {
        this.saleNum = saleNum;
    }

    public Date getCreatTime() {
        return creatTime;
    }

    public void setCreatTime(Date creatTime) {
        this.creatTime = creatTime;
    }

    public String getCategoryName() {
        return categoryName;
    }

    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public Map getSpec() {
        return spec;
    }

    public void setSpec(Map spec) {
        this.spec = spec;
    }

    public String getSpecStr() {
        return specStr;
    }

    public void setSpecStr(String specStr) {
        this.specStr = specStr;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", price=" + price +
                ", stock=" + stock +
                ", saleNum=" + saleNum +
                ", creatTime=" + creatTime +
                ", categoryName='" + categoryName + '\'' +
                ", brandName='" + brandName + '\'' +
                ", spec=" + spec +
                ", specStr='" + specStr + '\'' +
                '}';
    }
}

6.准备mapper及xml

GoodMapper

package com.hejiawang.elasticsearch.mapper;

import com.hejiawang.elasticsearch.domain.Goods;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@Mapper
public interface GoodsMapper {
    /*
    * 查询所有
    * */
    public List<Goods> findAll();
}

GoodMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.hejiawang.elasticsearch.mapper.GoodsMapper">
    <select id="findAll" resultType="goods">
        select id,
               title,
               price,
               stock,
               saleNum,
               creatTime,
               categoryName,
               brandName,
               spec as specStr
        from goods
    </select>
</mapper>

7.BulkRequest批量导入数据

    /*
    * 2.批量导入
    * */
    @Test
    public void importData() throws IOException {
//        1.查询所有数据，mysql
        List<Goods> goodsList = goodsMapper.findAll();
//        goodsList.forEach(n-> System.out.println(n.toString()));
//        2.导入数据
        BulkRequest bulkRequest = new BulkRequest();
//        2.1循环goodsList，创建IndexRequest添加数据
        for (Goods goods : goodsList) {
//            2.2设置spec规格信息，Map的数据 specStr{}
            goods.setSpec(JSON.parseObject(goods.getSpecStr(),Map.class));
//            System.out.println(goods.toString());
//            System.out.println(JSON.toJSONString(goods));
            IndexRequest indexRequest = new IndexRequest("goods");
            indexRequest.id(goods.getId()+"").source(JSON.toJSONString(goods), XContentType.JSON);
            bulkRequest.add(indexRequest);
        }
        BulkResponse response = client.bulk(bulkRequest,RequestOptions.DEFAULT);
    }

8.执行导入结果

在这里插入图片描述

各种查询

matchAll查询

在这里插入图片描述

matchALL脚本查询

GET http://127.0.0.1:9200/goods/_search
默认显示10条数据

{
    "query":{
        "match_all":{}
    }
}

在这里插入图片描述
分页需要带上from，size

{
    "query":{
        "match_all":{}
    },
    "from":0,
    "size":100
}

matchAll javaAPI操作

    /*
    * 查询所有
    * 1.matchAll
    * 2.将查询结果分装为Goods对象，封装到list中
    * 3.分页，默认为10条
    * */
    @Test
   public void testMatchAll() throws IOException {
//        1.构建查询条件构造器，指定查询索引名称
        SearchRequest searchRequest = new SearchRequest("goods");
//        2.创建查询条件构造对象
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        添加分页信息
        sourceBuilder.from(0);
        sourceBuilder.size(100);
//        3.指定查询条件
        MatchAllQueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); //查询所有文档
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
//        4.获取命中对象
        SearchHits searchHits = response.getHits();
//        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);

//        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

term查询

在这里插入图片描述

term脚本查询

GET http://127.0.0.1:9200/goods/_search

{
    "query":{
        "term":{
            "categoryName":{
                "value":"手机"
            }
        }
    }
}

在这里插入图片描述

termAPI查询

    /**
     * termQuery:词条查询
     */
    @Test
    public void testTermQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        TermQueryBuilder queryBuilder = QueryBuilders.termQuery("categoryName","手机"); //term词条查询
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

match查询

在这里插入图片描述

match脚本查询

GET http://127.0.0.1:9200/goods/_search

{
    "query":{
        "match":{
            "title":{
                "query":"三星",
                "operator":"and"
            }
        }
    }
}

在这里插入图片描述

match API查询

    /**
     * termQuery:Match查询
     */
    @Test
    public void testMatchQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title","三星"); //match词条查询
        queryBuilder.operator(Operator.AND); //求并集
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

其他查询

模糊查询脚本

在这里插入图片描述

模糊查询API

    /**
     * wildQuery:模糊查询
     */
    @Test
    public void testWildcardQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        WildcardQueryBuilder queryBuilder = QueryBuilders.wildcardQuery("title","三*"); 
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

正则查询脚本

在这里插入图片描述

正则查询API

    /**
     * RegexpQuery:正则查询
     */
    @Test
    public void testRegexpQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        RegexpQueryBuilder queryBuilder = QueryBuilders.regexpQuery("title","\\w+(.)*"); //
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

前缀查询脚本

在这里插入图片描述

前缀查询API

    /**
     * PrefixQuery:前缀查询
     */
    @Test
    public void testPrefixQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        PrefixQueryBuilder queryBuilder = QueryBuilders.prefixQuery("title","三"); //match词条查询
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

范围查询脚本

在这里插入图片描述
在这里插入图片描述

范围查询API

    /**
     * rangeQuery:范围查询
     */
    @Test
    public void testPrefixQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        RangeQueryBuilder queryBuilder = QueryBuilders.rangeQuery("price");
        queryBuilder.gte(2000);
        queryBuilder.lte(3000);
        sourceBuilder.query(queryBuilder);
//        排序
        sourceBuilder.sort("price", SortOrder.ASC);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

queryString脚本查询

在这里插入图片描述在这里插入图片描述

queryString API

    /**
     * queryString:范围查询
     */
    @Test
    public void testQueryString() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        QueryStringQueryBuilder queryBuilder = QueryBuilders.queryStringQuery("三星").field("title").field("brandName").defaultOperator(Operator.OR);
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
    }

在这里插入图片描述

布尔查询脚本

在这里插入图片描述
在这里插入图片描述

聚合查询脚本

在这里插入图片描述
在这里插入图片描述

聚合查询API

    /**
     * 聚合查询:桶聚合，分词查询
     * 1.查询title包含手机的数据
     * 2.查询品牌列表
     */
    @Test
    public void testAggQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        1.查询title包含三星的数据
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "三星");
        sourceBuilder.query(queryBuilder);
//        2.查询品牌列表
        /*
        * 参数
        *   1.自定义的名称，将来用于获取数据
        *   2.分组的字段
        * */
        TermsAggregationBuilder builder = AggregationBuilders.terms("goods_brands").field("brandName").size(100);
        sourceBuilder.aggregation(builder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
//        获取聚合结果
        Aggregations aggregations = response.getAggregations();
        Map<String, Aggregation> aggregationMap = aggregations.asMap();
//        System.out.println(aggregationMap);
        Terms goodsBrands = (Terms) aggregationMap.get("goods_brands");
        List<? extends Terms.Bucket> buckets = goodsBrands.getBuckets();
        List brands = new ArrayList();
        for (Terms.Bucket bucket: buckets){
            Object key = bucket.getKey();
            brands.add(key);
        }
        brands.forEach(System.out::println);
    }

在这里插入图片描述

高亮查询脚本

在这里插入图片描述

高亮查询API

    /**
     * 高亮查询:
     * 1.查询title包含手机的数据
     *  高亮字段
     *  前缀
     *  后缀
     *  2.讲高亮了的字段数据替换原有数据
     */
    @Test
    public void testHighLightQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        1.查询title包含三星的数据
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "苹果");
        sourceBuilder.query(queryBuilder);
//        2.设置高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
//        设置三要素
        highlightBuilder.field("title");
        highlightBuilder.preTags("<front color='red'>");
        highlightBuilder.postTags("</front>");
        sourceBuilder.highlighter(highlightBuilder);
//        2.查询品牌列表
        /*
         * 参数
         *   1.自定义的名称，将来用于获取数据
         *   2.分组的字段
         * */
        TermsAggregationBuilder builder = AggregationBuilders.terms("goods_brands").field("brandName").size(100);
        sourceBuilder.aggregation(builder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        //        5.获取总记录数
        long value = searchHits.getTotalHits().value;
        System.out.println("总记录数:"+value);
        //        获取Hits数据 数组
        List<Goods> goodsList = new ArrayList<>();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit:hits){
//           获取json字符串格式的数据
            String sourceAsString = hit.getSourceAsString();
//            System.out.println(sourceAsString);
//            转为json对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//            获取高亮结果，替换goods中的title
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField highlightField = highlightFields.get("title");
            Text[] fragments = highlightField.fragments();
//            替换
            goods.setTitle(fragments[0].toString());
            goodsList.add(goods);
        }
        goodsList.forEach(System.out::println);
//        获取聚合结果
        Aggregations aggregations = response.getAggregations();
        Map<String, Aggregation> aggregationMap = aggregations.asMap();
//        System.out.println(aggregationMap);
        Terms goodsBrands = (Terms) aggregationMap.get("goods_brands");
        List<? extends Terms.Bucket> buckets = goodsBrands.getBuckets();
        List brands = new ArrayList();
        for (Terms.Bucket bucket: buckets){
            Object key = bucket.getKey();
            brands.add(key);
        }
        brands.forEach(System.out::println);
    }

索引别名和重建索引

重建索引

1.创建V1索引

PUT http://127.0.0.1:9200/student_index_v1

{
    "mappings":{
        "properties":{
            "birthday":{
                "type":"date"
            }
        }
    }
}

2.往V1索引中插入数据

PUT http://127.0.0.1:9200/student_index_v1/_doc/1

{
    "birthday":"2000-11-21"
}

在这里插入图片描述

3.创建V2的索引

PUT http://127.0.0.1:9200/student_index_v2

{
    "mappings":{
        "properties":{
            "birthday":{
                "type":"date"
            }
        }
    }
}

4.将V1索引中的数据copy到V2索引中

PUT http://127.0.0.1:9200/_reindex

{
    "source":{
        "index":"student_index_v1"
    },
    "dest":{
        "index":"student_index_v2"
    }
}

在这里插入图片描述

对索引取别名

POST http://127.0.0.1:9200/student_index_v2/_alias/student_index_v3
在这里插入图片描述

ES集群管理

ES集群概念

在这里插入图片描述

ES分布式基本概念

在这里插入图片描述

ES分片原则及主机节点预估

在这里插入图片描述

ES路由原则

在这里插入图片描述

ES脑裂

脑裂原因

在这里插入图片描述

避免脑裂

在这里插入图片描述


http://lihuaxi.xjx100.cn/news/1207773.html

相关文章

chatgpt赋能python：Python地址怎么写的SEO

chatgpt赋能python：Python地址怎么写的SEO

Python地址怎么写的SEO 随着数字化时代的到来&#xff0c;搜索引擎优化&#xff08;SEO&#xff09;已成为网站排名和流量的重要因素。为了让Python 相关网站在搜索引擎上更加有利的排名&#xff0c;需要了解Python地址要怎么写才能获得更好的SEO效果。 为什么地址要写好 地…
阅读更多...
chatgpt赋能python：Python在一个程序里调用另一段程序

chatgpt赋能python：Python在一个程序里调用另一段程序

Python在一个程序里调用另一段程序 随着Python程序的复杂度越来越高&#xff0c;有时候一个程序难以处理所有的任务。这时候我们可能需要将任务拆分成多个脚本来执行。但是&#xff0c;这会导致代码的复杂性增加&#xff0c;同时也会增加可读性和维护成本。这时候&#xff0c;…
阅读更多...
chatgpt赋能python：Python图片定位：优化SEO的关键技术

chatgpt赋能python：Python图片定位：优化SEO的关键技术

Python图片定位&#xff1a;优化SEO的关键技术 在现代搜索引擎优化中&#xff0c;图片已成为吸引用户眼球和提升网站排名的关键元素之一。而Python作为一种功能强大的编程语言&#xff0c;在图片定位和SEO优化方面也具备很大的优势。 Python图片定位的基本原理 在Python中&a…
阅读更多...
操作系统（进程与线程，复习自用）

操作系统（进程与线程，复习自用）

进程与线程 进程与线程进程的概念、组成、特征进程的状态与转换进程控制进程通信&#xff08;IPC&#xff09;线程概念 多线程模型线程的实现方式 多线程模型线程的状态与转换 CPU调度与上下文切换调度的概念、层次进程调度的时机 切换与过程调度方式调度器 闲逛进程调度算法的…
阅读更多...
Redis及缓存击穿、穿透、雪崩

Redis及缓存击穿、穿透、雪崩

目录 优缺点 使用方法 使用场景 Redis缓存击穿、穿透、雪崩 Redis是一款开源的内存数据结构存储系统&#xff0c;它支持多种数据结构&#xff0c;包括字符串、哈希表、列表、集合、有序集合等。Redis的使用场景非常广泛&#xff0c;以下是一些常见的使用场景&#xff1a; 优…
阅读更多...
Vue3.0 为什么采用 Proxy

Vue3.0 为什么采用 Proxy

Object.defineProperty() 作用&#xff1a;在一个对象上定义一个新属性&#xff0c;或者修改一个对象的现有属性&#xff0c;并返回这个对象。 1. 基本使用 语法&#xff1a;Object.defineProperty(obj, prop, descriptor) 参数&#xff1a; 要添加属性的对象 要定义或修改…
阅读更多...
ABC304F Shift Table

ABC304F Shift Table

ABC304F Shift Table 题目大意 小 T T T和小 A A A要做 n n n天的工作。 小 T T T的工作表表示为字符串 S S S&#xff0c;其中“#”表示当天要工作&#xff0c;“.”表示当天不需要工作。 你需要安排小 A A A的工作&#xff0c;步骤如下 选择一个 n n n的约数 m m m&…
阅读更多...
JavaSE进阶（day13，复习自用）

JavaSE进阶（day13，复习自用）

单元测试、反射、注解、动态代理 单元测试单元测试概述单元测试快速入门单元测试常用注解 反射反射概述反射获取类对象反射获取构造器对象反射获取成员变量对象反射获取方法对象反射的作用-绕过编译阶段为集合添加数据反射的作用-通用框架的底层原理 注解注解概述自定义注解元注…
阅读更多...
最新文章

Copyright @ 2022~2023