postman调试es postman elasticsearch

一、搭建环境

1.1 docker安装启动ElasticSearch

• 选择在腾讯云服务器Centos7

1. 拉取最新版ElasticSearch

docker pull elasticsearch

若出现如下错误：

 表明需要添加版本信息才能正常下载

docker pull elasticsearch：7.6.1

安装成功！

2. 启动elasticsearch

• 指定映射端口号 -p，选择9200、9300端口
• 别名：mysearch

docker run -d -p 9200:9200 -p 9300:9300 --name mysearch elasticsearch:7.6.1

在浏览器上进行访问：

ip:9200

若通过docker ps -a查看到mysearch已经退出！则使用docker logs 容器号查看日志信息

从日志中可以看到有两个错误信息！

3. 诊断日志信息

1）max virtual memory 

• 报错原因：elasticsearch用户拥有的内存权限太小，至少需要262144

解决方案： 

• 切换到root环境
• 执行命令：sysctl -w vm.max_map_count=262144
• 查看：sysctl -a|grep vm.max_map_count

•  在/etc/sysctl.conf文件下，最后一行添加

vm.max_map_count=262144

• 执行：sysctl  -p,立即生效

2）the default discovery settings are unsuitable for production use

• 报错原因：需指定部署环境和模式

解决方法：

• 修改启动命令，加上-e "discovery.type=single-node"

docker run -d -p 9200:9200 -p 9300:9300 -e ES_JAVA_POTS="-Xms128m -Xmx128m" 
-e "discovery.type=single-node" --name mysearch elasticsearch:7.6.1

-e ES_JAVA_POTS="-Xms128m -Xmx128m" 表示运行所需内存，默认是1G

4. 运行成功

 

二、SpringBoot整合Elasticsearch 

2.1 创建springboot-web项目

• 引入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

• Spring Data

Spring Data可以帮助开发者减少样本代码的编写，比如定义一个接口，可以直接继承接口

ElasticSearchRepository接口，这样就实现了documents基础的CRUD方法，在ElasticSearch中index类型RDMS里table的概念，documents类型table里的datarow的概念，因此开发者不需要重复编写简单逻辑的方法。类型的还有Spring Data JPA。            

2.2 创建实体映射

@Document(indexName="productIndex")
public class Product {
    @Id
    private String id;
    
    @Field(type=FieldType.Text,name="name")
    private String name;

    @Field(type=FieldType.Double,name="price")
    private Double price;

    @Field(type=FieldType.Integer,name="quantity")
    private Integer quantity;

    @Field(type=FieldType.Keyword,name="category")
    private String category;

    @Field(type=FieldType.Keyword,name="description")
    private String description;

    @Field(type=FieldType.Date,name="createDateTime")
    private LocalDate createDateTime;

}

2.3 定义接口类

public interface ProductRepository extends 
        ElasticsearchRepository<Product,String> {
    Product findByName(String name);
    Page<Product> findByName(String name, PageRequest request);
    Page<Product> findByNameContaining(String name, PageRequest request);
}

2.4 定义elasticsearch配置类

@Configuration
@EnableElasticsearchRepositories(basePackages="com.xsbc.entity")
@ComponentScan(basePackages={"com.xsbc"})
public class ElasticSearchConfig extends AbstractElasticsearchConfiguration {

    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {
        ClientConfiguration config=ClientConfiguration
                .builder()
                .connectedTo("116.92.123.27:9200")
                .build();
        return RestClients.create(config).rest();
    }

    @Bean
    public ElasticsearchRestTemplate elasticsearchRestTemplate(){
        return new ElasticsearchRestTemplate(elasticsearchClient());
    }
}

2.5 测试

1. 创建和删除index 

ElasticsearchRepository默认创建了index

2. 添加documents

@Test
    // 创建documents
    void createProductDocument(){
        List<Product> products=new ArrayList<>();
        for(int i=1;i<=20;++i){
            Product product=new Product();
            product.setName("Java"+i)
                    .setPrice(25d)
                    .setQuantity(15)
                    .setCategory("newBook"+i)
                    .setDescription("A new JavaBook By XiaoChen"+i)
                    .setCreatedDateTime(LocalDate.now());
            products.add(product);
        }
        productRepository.saveAll(products);
        Assertions.assertEquals(products.size(),20);
    }

3. 查询documents

• 精确查询

@Test
    //精确查询
    public void findByName(){
        Product product=productRepository.findByName("Java15");
        //Assertions.assertEquals(product.getQuantity(),20);
        //Assertions.assertEquals(product.getPrice(),25d);
        System.out.println(product);
    }

• 匹配查询（模糊查询，支持分页查询）

@Test
    //匹配查询
    public void findByNameContaining(){
        Page<Product> pages=productRepository.findByNameContaining(
                "Java", PageRequest.of(0, 15));
        //Assertions.assertEquals(pages.toList().size(),10);
        for(Product product:pages){
            System.out.println(product);
        }
    }

4. 更新documents

@Test
    // 编辑documents
    public void updateProduct(){
        Product product=productRepository.findByName("Java15");
        product.setQuantity(25);
        productRepository.save(product);
        Assertions.assertEquals(25,product.getQuantity());
    }

5. 删除documents

@Test
    // 删除documents
    public void deleteProduct(){
        Product product=productRepository.findById("2G1QAn8BZgdTsFZbQJf6")
                        .get();
        productRepository.delete(product);
    }

三、Postman接口测试

3.1 Elasticsearch的数据格式

• Elasticsearch 是面向文档型数据库，一条数据在这里就是一个文档。为了方便大家理解，我们将 Elasticsearch 里存储文档数据和关系型数据库 MySQL 存储数据的概念进行一个类比。
• ES 里的 Index 可以看做一个库，而 Types 相当于表，Documents 则相当于表的行。这里 Types 的概念已经被逐渐弱化，Elasticsearch 6.X 中，一个 index 下已经只能包含一个 type，Elasticsearch 7.X 中, Type 的概念已经被删除了。

3.2 索引操作

1. 创建索引

• 在ES中创建一个索引，就相当于在mysql中创建了一个数据库，而mysql中的数据库肯定是不能重复的，也即ES中的索引也不能重复，所以这是一个幂等性操作，需要发送PUT请求（如果重复发送PUT请求、重复添加索引，会返回错误信息），这里不能发送POST请求。

 2. 查看指定索引

• 在 Postman 中，向 ES 服务器发 GET 请求。这里的路径和上面的创建索引是一样的，只是请求方式不一样。

 3. 查看全部索引

在 Postman 中，向 ES 服务器发 GET 请求。

• health：当前服务器健康状态，green(集群完整) yellow(单点正常、集群不完整) red(单点不正常)
• status：索引打开、关闭状态
• index：索引名
• uuid：索引统一编号
• pri：主分片数量
• rep：副本数量
• docs.count：可用文档数量
• docs.deleted：文档删除状态（逻辑删除）
• store.size：主分片和副分片整体占空间大小
• pri.store.size：主分片占空间大小

4. 删除索引

在 Postman 中，向 ES 服务器发 DELETE 请求。

 

 3.3 文档操作

1. 创建文档

• 索引已经创建好了，接下来我们来创建文档，并添加数据。这里的文档可以类比为关系型数据库中的表数据，添加的数据格式为 JSON 格式

在 Postman 中，向 ES 服务器发 POST 请求。

{
    "title": "Python入门教程",
    "category": "编程语言",
    "image": "http://www.xsbc.com/hua.jpg",
    "price": 40.5
}

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES 服务器会随机生成一个。如果想要自定义唯一性标识，需要在创建时指定。推荐使用下面这种方式创建文档。

http://127.0.0.1:9200/user/_doc/1001

 2. 查看单个文档：主键查询

• 查看文档时，需要指明文档的唯一性标识，类似于 MySQL 中数据的主键查询。在 Postman 中，向 ES 服务器发 GET 请求。

 

 3. 查看所有文档：全查询

• # "query"：这里的 query 代表一个查询对象，里面可以有不同的查询属性
• # "match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
• # {查询条件}：查询条件会根据类型的不同，写法也有差异

 4. 修改文档中的全部字段

• 修改数据时，也可以只修改某一给条数据的局部信息，也可以修改所有字段信息。
• 修完完之后，再次发送GET请求，查看修改后的文档内容。

{
    "title": "Java入门教程",
    "category": "编程语言",
    "image": "http://www.xsbc.com/hua.jpg",
    "price": 49.2
}

5. 修改文档中的某个字段

{
    "doc" : {
        "title":"C++入门教程",
        "category":"高级编程语言"
    }
}

6. 删除文档

• 删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）。在 Postman 中，向 ES 服务器发 DELETE 请求。

7. 条件查询文档内容

• match 匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是 or 的关系。

在 Postman 中，向 ES 服务器发 GET 请求。

 上面这种查询方式的请求参数是直接跟在请求路径之后的，这种方式不太好，因为有可能造成乱码问题。

所以一般采用下面这种方式，将请求参数存放在请求体中。

 8. 分页查询 + 排序文档内容

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在_source 的所有字段都返回。如果我们只想获取其中的部分字段，我们可以添加_source 的过滤

• sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc 升序。
• from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size。
• size：每页显示多少条。

 

{
    "query": {
        "match_all": {}
    },
    "from": 0, // (页码-1)*每页条数, 第一页：(1-1)*2=0, 第二页：(2-1)*2=2
    "size": 2,
    "_source": [
        "title",
        "price"
    ],
    "sort": {
        "price": {
            "order": "desc"
        }
    }
}

9. 多条件查询：and

• `bool`把各种其它查询通过`must`（必须 and ）、`must_not`（必须不）、`should`（应该 or）的方式进行组合 。

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "category": "编程语言"
                    }
                },
                {
                    "match": {
                        "price": 40.5
                    }
                }
            ]
        }
    }
}

10. 多条件查询：or

• `bool`把各种其它查询通过`must`（必须 and ）、`must_not`（必须不）、`should`（应该 or）的方式进行组合 。

{
    "query": {
        "bool": {
            "should": [
                {
                    "match": {
                        "category": "编程语言"
                    }
                },
                {
                    "match": {
                        "price": 49.2
                    }
                }
            ]
        }
    }
}

11. 多条件查询：大于、小于

• range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符：        gt （大于>）、te （大于等于>= ）、lt （小于<）、 lte（小于等于<=）

{
    "query": {
        "bool": {
            "should": [
                {
                    "match": {
                        "category": "编程语言"
                    }
                },
                {
                    "match": {
                        "price": 40.5
                    }
                }
            ]
        }
    }
}

12. 全文查询 + 高亮显示

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。 

在使用 match 查询的同时，加上一个 highlight 属性：

• pre_tags：前置标签
• post_tags：后置标签
• fields：需要高亮的字段
• title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以空

{
    "query": {
        "match_phrase": {
            "category": "编"
        }
    },
    "highlight": {
        "fields": {
            "category": {}
        }
    }
}

当我们将查询条件中的 match_phrase 改为 match 之后，再次查询，结果仍然是有的。这就很奇怪了，我文档中分类信息只有 小米 、没有 小 啊，为什么还能查询到结果呢？      这是因为ES在保存文档数据时，会将数据进行分词、拆解操作，并将拆解后的数据保存到倒排索引中，这样即使使用文字的一部分（小米可以查询到、小也可以查询到）也能查询到数据，这种方式就称为 全文检索。       也就是说文档中的category是小米，通过 小、米、小米 均可以查询到。如果我们写的是 小华，则ES会帮我们查询出：%小%、%华% 相关的所有数据，这里就是进行了数据分词、拆解，进而采用倒排索引的方式查询。假如说，我不想采用采用这种全文检索的匹配模式，需要将 match 改为 match_phrase。

 13. 聚合查询：根据价格分组、对价格求平均值

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

• 对某个字段取最大值 max
• 对某个字段取最小值 min
• 对某个字段求和 sum
• 对某个字段取平均值 avg
• 对某个字段的值进行去重之后再取总数 distinct

{
    "aggs" : { //聚合操作
        "price_group" : { //名称，自定义
            "terms" : { //分组
                "field" : "price" //分组字段
            }
        }
    },
    "size" : 0
}

 

{
    "aggs": { //聚合操作
        "price_avg": { //名称，自定义
            "avg": { //分组
                "field": "price" //分组字段
            }
        }
    },
    "size": 0
}

3.4 映射操作

有了索引库，等于有了数据库中的 database。

接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

映射数据说明：

• 字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price
• type：类型，Elasticsearch 中支持的数据类型非常丰富，说几个关键的：

                   String 类型，又分两种：
                             text：可分词

                             keyword：不可分词，数据会作为完整字段进行匹配
                   Numerical：数值类型，分两类
                             基本数据类型：long、integer、short、byte、double、float、half_float
                             浮点数的高精度类型：scaled_float
                   Date：日期类型
                   Array：数组类型
                   Object：对象

• index：是否索引，默认为 true，也就是说你不进行任何配置，所有字段都会被索引。

                    true：字段会被索引，则可以用来进行搜索
                    false：字段不会被索引，不能用来搜索

• store：是否将数据进行独立存储，默认为 false。原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置
• analyzer：分词器，这里的 ik_max_word 即使用 ik 分词器

首先是 http://127.0.0.1:9200/user ，发送PUT请求，创建一个user索引，然后在这个索引下创建一个映射。

• 就类似于在mysql中创建一个名为 user 的数据库，在这个数据库中定义一张表的结构如下：text 类型为true表示 name 字段可以支持 分词、拆解 操作的查询；而 keyword 类型为true表示 sex 字段仅支持完全匹配的模式；最后 keyword 类型为false表示 tel 字段不支持查询。

{
    "properties" : {
        "name" : {
            "type" : "text",
            "index" : true
        },
        "sex" : {
            "type" : "keyword",
            "index" : true
        },
        "tel" : {
            "type" : "keyword",
            "index" : false
        }
    }
}

• 索引有了，映射也有了（数据库有了、表结构有了，就差向表中添加数据了），也就是需要添加文档内容。

 

• 因为name字段是 支持 text 模式查询，即支持 分词、拆解 操作，做倒排索引，所以虽然文档中的name字段为张起灵，但是经过分词拆解，name为 张、起、灵、起灵 这几种都可以查询出数据。

• 由于 sex 字段不支持text分词拆解，仅支持keyword完全匹配的模式，所以源文档数据中 sex 为 man，这里只写个 m 是查询不到的。

• 最后的 tel 字段是最苛刻的，压根不支持 text、keyword 两种查询模式，所以这里就算是写成和文档中的 tel 一样，也查询不到，因为 tel 字段不支持查询。