基于脚手架微服务的视频点播系统-脚手架开发部分(完结)elasticsearch与libcurl的简单使用与二次封装及bug修复

基于脚手架微服务的视频点播系统-脚手架开发部分elasticsearch与libcurl的简单使用与二次封装及bug修复-完结

• 1.ElasticClient的使用
• • 1.1ES检索原理
  • • 正排索引
      • 倒排索引
  • 1.2ES核心概念
  • • 1.2.1索引(index)
      • 1.2.2类型(Field)
      • 1.2.3字段(Field)
      • 1.2.4映射(mapping)
      • 1.2.5文档(document)
  • 1.3 Kibana访问es进行测试
  • • 1.3.1创建索引
      • 1.3.2新增数据
      • 1.3.3查看并搜索数据
      • 1.3.4删除索引
  • 1.4典型操作
  • • 1.4.1索引
      • 1.4.2新增数据
      • • 1.4.2.1单数据新增
          * 1.4.2.2批量数据新增
          * 1.4.2.3查询所有数据
      • 1.4.3删除
      • • 1.4.3.1删除指定id的数据
          * 1.4.3.2批量删除指定id的数据
          * 1.4.3.3根据条件进行数据的删除
      • 1.4.4更新
      • • 1.4.4.1单数据更新
          * 1.4.4.2批量数据更新
      • 1.4.5查询
      • • 单条件查询
          * 多条件查询
  • 1.5ES客户端SDK
  • • 1.5.1接口介绍
      • • 1.响应结构
          * 2.典型接口
      • 1.5.2使用样例
  • 1.6二次封装
  • • 使用样例
• 2.libcurl的使用与封装
• • 2.1启用邮箱授权码(以163邮箱为例)
  • 2.2使用
  • • 2.2.1头文件与链接库
      • 2.2.2核心接口
      • 2.2.3链表操作
      • 2.2.4http选项
      • 2.2.5SMTP选项
  • 2.3二次封装
  • • 使用样例
• 3.bug修复
• • 3.1util⼯具类功能补充
  • 3.2RPC封装Bug与补充
  • 3.3MQ封装Bug
• 4.打包脚手架项目
• • 4.1在项目根目录创建如下CMakeLists.txt文件
  • 4.2在根目录下创建名为cmake的文件夹，并添加两个新文件
  • 4.3在根目下创建一个名为build的文件夹，进入并依次执行如下bash命令

1.ElasticClient的使用

Elasticsearch， 简称ES，它是个开源分布式搜索引擎，它的特点有：分布式，零配置，⾃动发现，索引⾃动分⽚，索引副本机制，restful⻛格接⼝，多数据源，⾃动搜索负载等。它可以近乎实时的存储、检索数据；本⾝扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es也使⽤Java开发并使⽤Lucene作为其核⼼来实现所有索引和搜索的功能，但是它的⽬的是通过简单的RESTful API来隐藏Lucene的复杂性，从⽽让全⽂搜索变得简单。
Elasticsearch是⾯向⽂档(document oriented)的，这意味着它可以存储整个对象或⽂档(document)。然⽽它不仅仅是存储，还会索引(index)每个⽂档的内容使之可以被搜索。在Elasticsearch中，你可以对⽂档（⽽⾮成⾏成列的数据）进⾏索引、搜索、排序、过滤。

1.1ES检索原理

正排索引

正排索引，也称为前向索引，是⼀种将⽂档或数据记录按照某种特定顺序组织的索引机制。在正排索引中，索引的键通常是⽂档的标识符，如⽂档ID，⽽索引的值则包含⽂档的详细信息，例如标题、内容摘要、发布⽇期等。这种结构使得正排索引⾮常适合执⾏基于特定标识符的查找操作。正排索引的优点在于能够直接根据⽂档ID快速访问⽂档，适合于需要按照⽂档顺序进⾏操作的场景。

倒排索引

倒排索引，⼜称反向索引或逆向索引，是按照⽂档中的词汇来组织数据的索引⽅法。在倒排索引中，每个独特的词汇都会有⼀个索引条⽬，该条⽬包含指向包含该词 的所有⽂档的指针或引⽤。这使得倒排索引⾮常适合全⽂搜索，能够快速找到包含特定关键词的⽂档。倒排索引则适合于全⽂搜索，可以快速找到包含特定关键词的所有⽂档，索引的⼤⼩相对较⼩，因为它只记录关键词和⽂档的映射关系。但是，倒排索引不能直接通过索引访问⽂档，需要结合正排索引来获取⽂档的详细信息。

1.2ES核心概念

ES中的一些概念与传统数据库可以做如下类比

这里需要注意的一点是，在es7.x版本之后，类型这个概念已经被废弃，也就是每个索引下只有一个类型就是_doc。我们访问一个索引中的文档时格式如下:/index/_doc/文档id。

1.2.1索引(index)

⼀个索引就是⼀个拥有⼏分相似特征的⽂档的集合。⽐如说，你可以有⼀个客⼾数据的索引，⼀个产品⽬录的索引，还有⼀个订单数据的索引。⼀个索引由⼀个名字来标识（必须全部是⼩写字⺟的），并且当我们要对应于这个索引中的⽂档进⾏索引、搜索、更新和删除的时候，都要使⽤到这个名字。在⼀个集群中，可以定义任意多的索引。

1.2.2类型(Field)

在⼀个索引中，你可以定义⼀种或多种类型。⼀个类型是你的索引的⼀个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有⼀组共同字段的⽂档定义⼀个类型。⽐如说，我们假设你运营⼀个博客平台并且将你所有的数据存储到⼀个索引中。在这个索引中，你可以为⽤⼾数据定义⼀个类型，为博客数据定义另⼀个类型，为评论数据定义另⼀个类型…

1.2.3字段(Field)

字段相当于是数据表的字段，对⽂档数据根据不同属性进⾏的分类标识。

1.2.4映射(mapping)

映射是在处理数据的⽅式和规则⽅⾯做⼀些限制，如某个字段的数据类型、默认值、分析器、是否被索引等等，这些都是映射⾥⾯可以设置的，其它就是处理es⾥⾯数据的⼀些使⽤规则设置也叫做映射，按着最优规则处理数据对性能提⾼很⼤，因此才需要建⽴映射，并且需要思考如何建⽴映射才能对性能更好。

1.2.5文档(document)

⼀个⽂档是⼀个可被索引的基础信息单元。⽐如，你可以拥有某⼀个客⼾的⽂档，某⼀个产品的⼀个⽂档或者某个订单的⼀个⽂档。⽂档以JSON（Javascript Object Notation）格式来表⽰，⽽JSON是⼀个到处存在的互联⽹数据交互格式。在⼀个index/type⾥⾯，你可以存储任意多的⽂档。⼀个⽂档必须被索引或者赋予⼀个索引的type。

1.3 Kibana访问es进行测试

通过⽹⻚访问kibana： http://192.168.65.128:5601/ ，注意：将链接中的IP地址改换成为你的主机IP地址。
默认账户密码为:elastic:123456

在开发工具中进行以下实验即可:

1.3.1创建索引

1PUT /user
2        {
3        "settings": {
4                "analysis": {
5                "analyzer": {
6                    "ikmax": {
7                    "type": "custom",
8                    "tokenizer": "ik_max_word"
9                    }
10                }
11                }
12            },
13            "mappings": {
14                "dynamic": false,
15                "properties": {
16                "name": {
17                    "type": "text",
18                    "boost": 3,
19                    "analyzer": "ikmax"
20                },
21                "age": {
22                    "type": "integer"
23                },
24                "phone": {
25                    "type": "keyword",
26                    "boost": 1
27                },
28                "skills": {
29                    "type": "text"
30                },
31                "birth": {
32                    "type": "date",
33                    "index": false,
34                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
35                }
36            }
37        }
38    }
39

1.3.2新增数据

1POST /user/_doc/_bulk
2{"index":{"_id":"1"}}
3{"user_id" : "USER4b862aaa-2df8654a-7eb4bb65-e3507f66","nickname" : "昵称
41","phone" : "⼿机号1","description" : "签名1","avatar_id" : "头像1"}
5{"index":{"_id":"2"}}
6{"user_id" : "USER14eeeaa5-442771b9-0262e455-e4663d1d","nickname" : "昵称
72","phone" : "⼿机号2","description" : "签名2","avatar_id" : "头像2"}
8{"index":{"_id":"3"}}
9{"user_id" : "USER484a6734-03a124f0-996c169d-d05c1869","nickname" : "昵称
103","phone" : "⼿机号3","description" : "签名3","avatar_id" : "头像3"}
11{"index":{"_id":"4"}}
12{"user_id" : "USER186ade83-4460d4a6-8c08068f-83127b5d","nickname" : "昵称
134","phone" : "⼿机号4","description" : "签名4","avatar_id" : "头像4"}
14{"index":{"_id":"5"}}
15{"user_id" : "USER6f19d074-c33891cf-23bf5a83-57189a19","nickname" : "昵称
165","phone" : "⼿机号5","description" : "签名5","avatar_id" : "头像5"}
17{"index":{"_id":"6"}}
18{"user_id" : "USER97605c64-9833ebb7-d0455353-35a59195","nickname" : "昵称
196","phone" : "⼿机号6","description" : "签名6","avatar_id" : "头像6"}
20

1.3.3查看并搜索数据

1GET /user/_doc/_search?pretty
2{
3    "query" : {
4        "bool" : {
5            "must_not" : [
6            {
7                "terms" : {
8                    "user_id.keyword" : [
9                    "USER4b862aaa-2df8654a-7eb4bb65-e3507f66",
10                    "USER14eeeaa5-442771b9-0262e455-e4663d1d",
11                    "USER484a6734-03a124f0-996c169d-d05c1869"
12                    ]
13                }
14            }
15            ],
16            "should" : [
17            {
18                "match" : {
19                    "user_id" : "昵称"
20                }
21            },
22            {
23                "match" : {
24                    "nickname" : "昵称"
25                }
26            },
27            {
28                "match" : {
29                    "phone" : "昵称"
30                }
31            }
32            ]
33        }
34    }
35}
36

1.3.4删除索引

1DELETE /user
2

1.4典型操作

ES中的操作，是基于Restful⻛格的接⼝，使⽤HTTP协议进⾏通信，通信的时候正⽂采⽤JSON格式进⾏序列化。
因此，在组织请求的过程中，更多关注的⽅⾯：

• 请求⽅法
• 请求的URI路径
• 请求正⽂中的各个关键字段

1.4.1索引

创建索引

1PUT /student
2{
3        "settings": {
4                "analysis": {
5                "analyzer": {
6                    "ikmax": {
7                    "type": "custom",
8                    "tokenizer": "ik_max_word"
9                    }
10                }
11                }
12            },
13            "mappings": {
14                "dynamic": false,
15                "properties": {
16                "name": {
17                    "type": "text",
18                    "boost": 3,
19                    "analyzer": "ikmax"
20                },
21                "age": {
22                    "type": "integer"
23                },
24                "phone": {
25                    "type": "keyword",
26                    "boost": 1
27                },
28                "skills": {
29                    "type": "text"
30                },
31                "birth": {
32                    "type": "date",
33                    "index": false,
34                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
35                }
36            }
37        }
38    }
39

删除索引

1DELETE /student
2

1.4.2新增数据

1.4.2.1单数据新增

URI组成： /索引名称/⽂档类型名称[/当前⽂档ID]

1POST /student/_doc/2
2{
3    "name":"lisi",
4    "age": 22,
5    "phone":"15522222222",
6    "skills":[
7    "C++",
8    "Python"
9    ],
10    "birth":"2018-08-19 22:22:33"
11}
12

1.4.2.2批量数据新增

正⽂格式要求： 每个⽂档包含两⾏内容：1. 索引信息； 2. ⽂档信息

1POST /student/_doc/_bulk
2{"index":{"_id":"1"}}
3{"name":"zhangsan","age":18,"phone":"15511111111","skills":["C++",
4"Java"],"birth":"2017-08-19 22:22:22"}
5{"index":{"_id":"6"}}
6{"name":"lisi","age":19,"phone":"15522222222","skills":["C++",
7"Python"],"birth":"2018-08-19 22:22:33"}
8{"index":{"_id":"3"}}
9{"name":"wangwu","age":30,"phone":"15533333333","skills":["Php",
10"Python"],"birth":"2028-08-19 22:22:44"}
11{"index":{"_id":"4"}}
12{"name":"lisi w","age":20,"phone":"15544444444","skills":["Php",
13"Java"],"birth":"2038-08-19 22:22:55"}
14{"index":{"_id":"5"}}
15{"name":"lisi z","age":10,"phone":"15555555555","skills":["YYY",
16"BBBB"],"birth":"2048-08-19 22:22:11"}
17

1.4.2.3查询所有数据

1POST /student/_doc/_search
2{
3	"query": {
4		"match_all": {}
5	}
6}
7

1.4.3删除

1.4.3.1删除指定id的数据

1DELETE /student/_doc/1
2

1.4.3.2批量删除指定id的数据

1POST /student/_doc/_bulk
2{ "delete": { "_id": "2" } }
3{ "delete": { "_id": "3" } }
4

1.4.3.3根据条件进行数据的删除

1POST /student/_doc/_delete_by_query
2{
3    "query": {
4        "match": {
5            "name": "lisi"
6        }
7    }
8}
9

1.4.4更新

1.4.4.1单数据更新

1POST /student/_update/1
2{
3    "doc": {
4        "phone": "18888888888",
5        "age": 19
6    }
7}
8

1.4.4.2批量数据更新

1POST /student/_doc/_bulk
2{"update":{"_id":"1"}}
3{ "doc": { "phone": "11111111111" } }
4{"update":{"_id":"2"}}
5{ "doc": { "phone": "22222222222" } }
6{"update":{"_id":"3"}}
7{ "doc": { "phone": "33333333333" } }
8

除了以上两种⽅式进⾏更新，也可以以新增单个数据的⽅式进⾏全字段更新。

1.4.5查询

单条件查询

1.term查询,单字段精确匹配(如果字段没有keyword属性时比如下方例子去掉.keyword，便是一种模糊匹配，有则都是精确匹配)

1POST /student/_doc/_search
2{
3    "query" : {
4        "term" : {
5            "name.keyword" : "lisi"
6        }
7    }
8}
9

2.terms单字段多值精确匹配

1{
2    "query" : {
3        "terms" : {
4            "phone" : [
5            "15511111111",
6            "15522222222"
7            ]
8        }
9    }
10}
11

3.match单字段模糊匹配

1{
2	"query" : {
3	"match" : {
4		"name" : "z"
5		}
6	}
7}
8

4.数字类型区间匹配

1{
2    "query" : {
3    "range" : {
4        "age" : {
5            "gte" : 10,
6            "lte" : 20
7        }
8    }
9}
10

5.多字段模糊匹配

1{
2    "query" : {
3        "multi_match" : {
4            "fields" : [
5            "name",
6            "phone"
7            ],
8            "query" : "zhangsan"
9        }
10    }
11}
12

多条件查询

bool检索 • must：必须匹配的条件 • must_not ： 必须过滤掉的条件 • should： 匹配⼀个或多个都可以 minimum_should_match：should中⾄少应该匹配n个条件

1{
2    "query" : {
3        "bool" : {
4            "must" : [
5            {
6                "match" :
7                {
8                    "skills" : "C++"
9                }
10            },
11            ],
12            "must_not" : [
13            {
14                "terms" : {
15                    "phone" : [
16                    "15522222222",
17                    "15555555555"
18                    ]
19                }
20            }
21            ],
22            "should" : [
23            {
24                "match" : {
25                    "name" : "lisi"
26                }
27            },
28            {
29                "terms" : {
30                    "phone" : [
31                    "15511111111",
32                    "15555555555"
33                    ]
34                }
35            }
36            ] 
37            "minimum_should_match" : 1,
38        }
39    }
40}
41

sort检索

1{
2    "query" : {
3        "bool" : {
4            "minimum_should_match" : 1,
5            "should" : [
6            {
7                "match" : {
8                    "name" : "lisi"
9                }
10            },
11            {
12                "terms" : {
13                    "phone" :
14                    [
15                    "15511111111",
16                    "15533333333"
17                    ]
18                }
19            }
20            ]
21        }
22    },
23    "sort" : [
24    {
25        "name.keyword" : "desc"
26    },
27    {
28        "age" : "asc"
29    }
30    ]
31} 
32#结果⽰例
33[
34{
35    "age" : 18,
36    "birth" : "2017-08-19 22:22:22",
37    "name" : "zhangsan",
38    "phone" : "15511111111",
39    "skills" : [
40    "C++",
41    "Java"
42    ]
43},
44{
45    "age" : 10,
46    "birth" : "2048-08-19 22:22:11",
47    "name" : "lisi z",
48    "phone" : "15555555555",
49    "skills" : [
50    "YYY",
51    "BBBB"
52    ]
53},
54{
55    "age" : 20,
56    "birth" : "2038-08-19 22:22:55",
57    "name" : "lisi w",
58    "phone" : "15544444444",
59    "skills" : [
60    "Php",
61    "Java"
62    ]
63},
64{
65    "age" : 19,
66    "birth" : "2018-08-19 22:22:33",
67    "name" : "lisi",
68    "phone" : "15522222222",
69    "skills" : [
70    "C++",
71    "Python"
72    ]
73}
74]
75

分⻚查找 对检索按指定⽅式进⾏排序，并限制获取结果数量，以及偏移量

1{
2    "query" :
3    {
4        "bool" :
5        {
6            "minimum_should_match" : 1,
7            "should" :
8            [
9            {
10                "match" :
11                {
12                    "name" : "lisi"
13                }
14            },
15            {
16                "terms" :
17                {
18                    "phone" :
19                    [
20                    "15511111111",
21                    "15533333333"
22                    ]
23                }
24            }
25            ]
26        }
27    },
28    "size" : 10,
29    "from" : 2,
30    "sort" :
31    [
32    {
33        "name.keyword" : "desc"
34    },
35    {
36        "age" : "asc"
37    }
38    ]
39} [
40{
41    "age" : 18,
42    "birth" : "2017-08-19 22:22:22",
43    "name" : "zhangsan",
44    "phone" : "15511111111",
45    "skills" :
46    [
47    "C++",
48    "Java"
49    ]
50},
51{
52    "age" : 10,
53    "birth" : "2048-08-19 22:22:11",
54    "name" : "lisi z",
55    "phone" : "15555555555",
56    "skills" :
57    [
58    "YYY",
59    "BBBB"
60    ]
61}
62

1.5ES客户端SDK

代码
官网
ES C++的客⼾端选择并不多， 我们这⾥使⽤elasticlient库, 下⾯进⾏安装。

1.5.1接口介绍

1.响应结构

1namespace cpr {
2    class Response {
3        public:
4        long status_code{};
5        std::string text{};
6        Header header{};
7        Url url{};
8        double elapsed{};
9        Cookies cookies{};
10        Error error{};
11        std::string raw_header{};
12        std::string status_line{};
13        std::string reason{};
14    };
15}
16

2.典型接口

1namespace elasticlient {
2    class Client {
3        // http://user:password@localhost:9200/
4        Client(const std::vector<std::string> &hostUrlList,
5               std::int32_t timeout = 6000);
6        /**
7* Perform search on nodes until it is successful. Throws exception if all
8nodes
9* has failed to respond.
10* \param indexName specification of an Elasticsearch index.
11* \param docType specification of an Elasticsearch document type.
12* \param body Elasticsearch request body.
13* \param routing Elasticsearch routing. If empty, no routing has been used.
14* \return cpr::Response if any of node responds to request.
15* \throws ConnectionException if all hosts in cluster failed to respond.
16*/
17        cpr::Response search(const std::string &indexName,
18                             const std::string &docType,
19                             const std::string &body,
20                             const std::string &routing = std::string());
21        /**
22* Get document with specified id from cluster. Throws exception if all nodes
23* has failed to respond.
24* \param indexName specification of an Elasticsearch index.
25* \param docType specification of an Elasticsearch document type.
26* \param id Id of document which should be retrieved.
27* \param routing Elasticsearch routing. If empty, no routing has been used.
28* *
29\return cpr::Response if any of node responds to request.
30* \throws ConnectionException if all hosts in cluster failed to respond.
31*/
32        cpr::Response get(const std::string &indexName,
33                          const std::string &docType,
34                          const std::string &id = std::string(),
35                          const std::string &routing = std::string());
36        /**
37* Index new document to cluster. Throws exception if all nodes has failed to
38respond.
39* \param indexName specification of an Elasticsearch index.
40* \param docType specification of an Elasticsearch document type.
41* \param body Elasticsearch request body.
42* \param id Id of document which should be indexed. If empty, id will be
43generated
44* automatically by Elasticsearch cluster.
45* \param routing Elasticsearch routing. If empty, no routing has been used.
46* *
47\return cpr::Response if any of node responds to request.
48* \throws ConnectionException if all hosts in cluster failed to respond.
49*/
50        cpr::Response index(const std::string &indexName,
51                            const std::string &docType,
52                            const std::string &id,
53                            const std::string &body,
54                            const std::string &routing = std::string());
55        /**
56* Delete document with specified id from cluster. Throws exception if all
57nodes
58* has failed to respond.
59* \param indexName specification of an Elasticsearch index.
60* \param docType specification of an Elasticsearch document type.
61* \param id Id of document which should be deleted.
62* \param routing Elasticsearch routing. If empty, no routing has been used.
63* *
64\return cpr::Response if any of node responds to request.
65* \throws ConnectionException if all hosts in cluster failed to respond.
66*/
67        cpr::Response remove(const std::string &indexName,
68                             const std::string &docType,
69                             const std::string &id,
70                             const std::string &routing = std::string());
71    } }
72

1.5.2使用样例

1#include <cpr/response.h>
2#include <elasticlient/client.h>
3#include <iostream>
4
5const std::string index_name = "student";
6const std::string doc_type = "_doc";
7const std::string doc_id = "default_id";
8
9void add_index(elasticlient::Client& client){
10    std::string body = R"(
11        {
12        "settings": {
13                "analysis": {
14                "analyzer": {
15                    "ikmax": {
16                    "type": "custom",
17                    "tokenizer": "ik_max_word"
18                    }
19                }
20                }
21            },
22            "mappings": {
23                "dynamic": false,
24                "properties": {
25                "name": {
26                    "type": "text",
27                    "boost": 3,
28                    "analyzer": "ikmax"
29                },
30                "age": {
31                    "type": "integer"
32                },
33                "phone": {
34                    "type": "keyword",
35                    "boost": 1
36                },
37                "skills": {
38                    "type": "text"
39                },
40                "birth": {
41                    "type": "date",
42                    "index": false,
43                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
44                }
45            }
46        }
47    })";
48    auto resp = client.performRequest(elasticlient::Client::HTTPMethod::PUT,index_name,body);
49    if(resp.status_code < 200 || resp.status_code >= 300){
50        std::cerr << "创建索引失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
51    }
52}
53
54void add_data(elasticlient::Client& client){
55    std::string body = R"({
56            "name": "张三",
57            "age": 19,
58            "phone": "13888888888",
59            "skills": ["java","php","go"],
60            "birth": "2007-05-21 12:35:32"})";
61    auto resp = client.index(index_name,doc_type,"1",body);
62    if(resp.status_code < 200 || resp.status_code >= 300){
63        std::cerr << "添加数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
64    }
65}
66
67void mod_data(elasticlient::Client& client){
68    //注意必须是全量插入，否则会导致除了更新字段其他字段全部被删除
69        std::string body = R"({
70            "name": "张三",
71            "age": 19,
72            "phone": "13333333333",
73            "skills": ["java","php","go"],
74            "birth": "2007-05-21 12:35:32"})";
75    //插入进行数据修改，也就是先删除原有数据再进行新增，一般不使用update方法对数据进行更新，此三方库中也并不提供update方法
76    auto resp = client.index(index_name,doc_type,"1",body);
77    if(resp.status_code < 200 || resp.status_code >= 300){
78        std::cerr << "修改数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
79    }
80}
81
82void search_data(elasticlient::Client& client){
83    //按照测试函数的顺序执行这几个测试函数，会因为请求过快而查不到对应数据
84    std::string query = R"({"query": {"match_all": {}}})";
85    auto resp = client.search(index_name,doc_type,query);
86    if(resp.status_code < 200 || resp.status_code >= 300){
87        std::cerr << "搜索数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
88    }else{
89        std::cout << "搜索结果:" << resp.text << std::endl;
90    }
91}
92
93void remove_data(elasticlient::Client& client){
94    auto resp = client.remove(index_name,doc_type,"1");
95    if(resp.status_code < 200 || resp.status_code >= 300){
96        std::cerr << "删除数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
97    }
98}
99
100void remove_index(elasticlient::Client& client){
101    auto resp = client.performRequest(elasticlient::Client::HTTPMethod::DELETE,index_name,"");
102    if(resp.status_code < 200 || resp.status_code >= 300){
103        std::cerr << "删除索引失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
104    }
105}
106
107int main(){
108    //设置服务端访问url
109    const std::string url = "http://elastic:[email protected]:9200/";//记得一定要加上最后的/不然会报错
110    //创建elasticlient客户端
111    elasticlient::Client client({url});
112    //测试
113    add_index(client);//如果存在会创建失败
114    add_data(client);
115    mod_data(client);
116    search_data(client);
117    remove_data(client);
118    remove_index(client);
119    return 0;
120}
121