@TOC

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创建索引

xxxxxxxxxx
PUT /user
        {
        "settings": {
                "analysis": {
                "analyzer": {
                    "ikmax": {
                    "type": "custom",
                    "tokenizer": "ik_max_word"
                    }
                }
                }
            },
            "mappings": {
                "dynamic": false,
                "properties": {
                "name": {
                    "type": "text",
                    "boost": 3,
                    "analyzer": "ikmax"
                },
                "age": {
                    "type": "integer"
                },
                "phone": {
                    "type": "keyword",
                    "boost": 1
                },
                "skills": {
                    "type": "text"
                },
                "birth": {
                    "type": "date",
                    "index": false,
                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
                }
            }
        }
    }

1.3.2新增数据

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

1.3.3查看并搜索数据

xxxxxxxxxx
GET /user/_doc/_search?pretty
{
    "query" : {
        "bool" : {
            "must_not" : [
            {
                "terms" : {
                    "user_id.keyword" : [
                    "USER4b862aaa-2df8654a-7eb4bb65-e3507f66",
                    "USER14eeeaa5-442771b9-0262e455-e4663d1d",
                    "USER484a6734-03a124f0-996c169d-d05c1869"
                    ]
                }
            }
            ],
            "should" : [
            {
                "match" : {
                    "user_id" : "昵称"
                }
            },
            {
                "match" : {
                    "nickname" : "昵称"
                }
            },
            {
                "match" : {
                    "phone" : "昵称"
                }
            }
            ]
        }
    }
}

1.3.4删除索引

xxxxxxxxxx
DELETE /user

1.4典型操作

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

• 请求⽅法

• 请求的URI路径

• 请求正⽂中的各个关键字段

1.4.1索引

创建索引

xxxxxxxxxx
PUT /student
{
        "settings": {
                "analysis": {
                "analyzer": {
                    "ikmax": {
                    "type": "custom",
                    "tokenizer": "ik_max_word"
                    }
                }
                }
            },
            "mappings": {
                "dynamic": false,
                "properties": {
                "name": {
                    "type": "text",
                    "boost": 3,
                    "analyzer": "ikmax"
                },
                "age": {
                    "type": "integer"
                },
                "phone": {
                    "type": "keyword",
                    "boost": 1
                },
                "skills": {
                    "type": "text"
                },
                "birth": {
                    "type": "date",
                    "index": false,
                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
                }
            }
        }
    }

删除索引

xxxxxxxxxx
DELETE /student

1.4.2新增数据

1.4.2.1单数据新增

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

xxxxxxxxxx
POST /student/_doc/2
{
    "name":"lisi",
    "age": 22,
    "phone":"15522222222",
    "skills":[
    "C++",
    "Python"
    ],
    "birth":"2018-08-19 22:22:33"
}

1.4.2.2批量数据新增

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

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

1.4.2.3查询所有数据

xxxxxxxxxx
POST /student/_doc/_search
{
    "query": {
        "match_all": {}
    }
}

1.4.3删除

1.4.3.1删除指定id的数据

xxxxxxxxxx
DELETE /student/_doc/1

1.4.3.2批量删除指定id的数据

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

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

xxxxxxxxxx
POST /student/_doc/_delete_by_query
{
    "query": {
        "match": {
            "name": "lisi"
        }
    }
}

1.4.4更新

1.4.4.1单数据更新

xxxxxxxxxx
POST /student/_update/1
{
    "doc": {
        "phone": "18888888888",
        "age": 19
    }
}

1.4.4.2批量数据更新

xxxxxxxxxx
POST /student/_doc/_bulk
{"update":{"_id":"1"}}
{ "doc": { "phone": "11111111111" } }
{"update":{"_id":"2"}}
{ "doc": { "phone": "22222222222" } }
{"update":{"_id":"3"}}
{ "doc": { "phone": "33333333333" } }

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

1.4.5查询

单条件查询

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

xxxxxxxxxx
POST /student/_doc/_search
{
    "query" : {
        "term" : {
            "name.keyword" : "lisi"
        }
    }
}

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

xxxxxxxxxx
{
    "query" : {
        "terms" : {
            "phone" : [
            "15511111111",
            "15522222222"
            ]
        }
    }
}

3.match单字段模糊匹配

xxxxxxxxxx
{
    "query" : {
    "match" : {
        "name" : "z"
        }
    }
}

4.数字类型区间匹配

xxxxxxxxxx
{
    "query" : {
    "range" : {
        "age" : {
            "gte" : 10,
            "lte" : 20
        }
    }
}

5.多字段模糊匹配

xxxxxxxxxx
{
    "query" : {
        "multi_match" : {
            "fields" : [
            "name",
            "phone"
            ],
            "query" : "zhangsan"
        }
    }
}

多条件查询

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

xxxxxxxxxx
{
    "query" : {
        "bool" : {
            "must" : [
            {
                "match" :
                {
                    "skills" : "C++"
                }
            },
            ],
            "must_not" : [
            {
                "terms" : {
                    "phone" : [
                    "15522222222",
                    "15555555555"
                    ]
                }
            }
            ],
            "should" : [
            {
                "match" : {
                    "name" : "lisi"
                }
            },
            {
                "terms" : {
                    "phone" : [
                    "15511111111",
                    "15555555555"
                    ]
                }
            }
            ] 
            "minimum_should_match" : 1,
        }
    }
}

sort检索

xxxxxxxxxx
{
    "query" : {
        "bool" : {
            "minimum_should_match" : 1,
            "should" : [
            {
                "match" : {
                    "name" : "lisi"
                }
            },
            {
                "terms" : {
                    "phone" :
                    [
                    "15511111111",
                    "15533333333"
                    ]
                }
            }
            ]
        }
    },
    "sort" : [
    {
        "name.keyword" : "desc"
    },
    {
        "age" : "asc"
    }
    ]
} 
#结果⽰例
[
{
    "age" : 18,
    "birth" : "2017-08-19 22:22:22",
    "name" : "zhangsan",
    "phone" : "15511111111",
    "skills" : [
    "C++",
    "Java"
    ]
},
{
    "age" : 10,
    "birth" : "2048-08-19 22:22:11",
    "name" : "lisi z",
    "phone" : "15555555555",
    "skills" : [
    "YYY",
    "BBBB"
    ]
},
{
    "age" : 20,
    "birth" : "2038-08-19 22:22:55",
    "name" : "lisi w",
    "phone" : "15544444444",
    "skills" : [
    "Php",
    "Java"
    ]
},
{
    "age" : 19,
    "birth" : "2018-08-19 22:22:33",
    "name" : "lisi",
    "phone" : "15522222222",
    "skills" : [
    "C++",
    "Python"
    ]
}
]

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

xxxxxxxxxx
{
    "query" :
    {
        "bool" :
        {
            "minimum_should_match" : 1,
            "should" :
            [
            {
                "match" :
                {
                    "name" : "lisi"
                }
            },
            {
                "terms" :
                {
                    "phone" :
                    [
                    "15511111111",
                    "15533333333"
                    ]
                }
            }
            ]
        }
    },
    "size" : 10,
    "from" : 2,
    "sort" :
    [
    {
        "name.keyword" : "desc"
    },
    {
        "age" : "asc"
    }
    ]
} [
{
    "age" : 18,
    "birth" : "2017-08-19 22:22:22",
    "name" : "zhangsan",
    "phone" : "15511111111",
    "skills" :
    [
    "C++",
    "Java"
    ]
},
{
    "age" : 10,
    "birth" : "2048-08-19 22:22:11",
    "name" : "lisi z",
    "phone" : "15555555555",
    "skills" :
    [
    "YYY",
    "BBBB"
    ]
}

1.5ES客户端SDK

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

1.5.1接口介绍

1.响应结构

xxxxxxxxxx
namespace cpr {
    class Response {
        public:
        long status_code{};
        std::string text{};
        Header header{};
        Url url{};
        double elapsed{};
        Cookies cookies{};
        Error error{};
        std::string raw_header{};
        std::string status_line{};
        std::string reason{};
    };
}

2.典型接口

xxxxxxxxxx
namespace elasticlient {
    class Client {
        // http://user:password@localhost:9200/
        Client(const std::vector<std::string> &hostUrlList,
               std::int32_t timeout = 6000);
        /**
* Perform search on nodes until it is successful. Throws exception if all
nodes
* has failed to respond.
* \param indexName specification of an Elasticsearch index.
* \param docType specification of an Elasticsearch document type.
* \param body Elasticsearch request body.
* \param routing Elasticsearch routing. If empty, no routing has been used.
* \return cpr::Response if any of node responds to request.
* \throws ConnectionException if all hosts in cluster failed to respond.
*/
        cpr::Response search(const std::string &indexName,
                             const std::string &docType,
                             const std::string &body,
                             const std::string &routing = std::string());
        /**
* Get document with specified id from cluster. Throws exception if all nodes
* has failed to respond.
* \param indexName specification of an Elasticsearch index.
* \param docType specification of an Elasticsearch document type.
* \param id Id of document which should be retrieved.
* \param routing Elasticsearch routing. If empty, no routing has been used.
* *
\return cpr::Response if any of node responds to request.
* \throws ConnectionException if all hosts in cluster failed to respond.
*/
        cpr::Response get(const std::string &indexName,
                          const std::string &docType,
                          const std::string &id = std::string(),
                          const std::string &routing = std::string());
        /**
* Index new document to cluster. Throws exception if all nodes has failed to
respond.
* \param indexName specification of an Elasticsearch index.
* \param docType specification of an Elasticsearch document type.
* \param body Elasticsearch request body.
* \param id Id of document which should be indexed. If empty, id will be
generated
* automatically by Elasticsearch cluster.
* \param routing Elasticsearch routing. If empty, no routing has been used.
* *
\return cpr::Response if any of node responds to request.
* \throws ConnectionException if all hosts in cluster failed to respond.
*/
        cpr::Response index(const std::string &indexName,
                            const std::string &docType,
                            const std::string &id,
                            const std::string &body,
                            const std::string &routing = std::string());
        /**
* Delete document with specified id from cluster. Throws exception if all
nodes
* has failed to respond.
* \param indexName specification of an Elasticsearch index.
* \param docType specification of an Elasticsearch document type.
* \param id Id of document which should be deleted.
* \param routing Elasticsearch routing. If empty, no routing has been used.
* *
\return cpr::Response if any of node responds to request.
* \throws ConnectionException if all hosts in cluster failed to respond.
*/
        cpr::Response remove(const std::string &indexName,
                             const std::string &docType,
                             const std::string &id,
                             const std::string &routing = std::string());
    } }

1.5.2使用样例

xxxxxxxxxx
#include <cpr/response.h>
#include <elasticlient/client.h>
#include <iostream>

const std::string index_name = "student";
const std::string doc_type = "_doc";
const std::string doc_id = "default_id";

void add_index(elasticlient::Client& client){
    std::string body = R"(
        {
        "settings": {
                "analysis": {
                "analyzer": {
                    "ikmax": {
                    "type": "custom",
                    "tokenizer": "ik_max_word"
                    }
                }
                }
            },
            "mappings": {
                "dynamic": false,
                "properties": {
                "name": {
                    "type": "text",
                    "boost": 3,
                    "analyzer": "ikmax"
                },
                "age": {
                    "type": "integer"
                },
                "phone": {
                    "type": "keyword",
                    "boost": 1
                },
                "skills": {
                    "type": "text"
                },
                "birth": {
                    "type": "date",
                    "index": false,
                    "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
                }
            }
        }
    })";
    auto resp = client.performRequest(elasticlient::Client::HTTPMethod::PUT,index_name,body);
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "创建索引失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }
}

void add_data(elasticlient::Client& client){
    std::string body = R"({
            "name": "张三",
            "age": 19,
            "phone": "13888888888",
            "skills": ["java","php","go"],
            "birth": "2007-05-21 12:35:32"})";
    auto resp = client.index(index_name,doc_type,"1",body);
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "添加数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }
}

void mod_data(elasticlient::Client& client){
    //注意必须是全量插入，否则会导致除了更新字段其他字段全部被删除
        std::string body = R"({
            "name": "张三",
            "age": 19,
            "phone": "13333333333",
            "skills": ["java","php","go"],
            "birth": "2007-05-21 12:35:32"})";
    //插入进行数据修改，也就是先删除原有数据再进行新增，一般不使用update方法对数据进行更新，此三方库中也并不提供update方法
    auto resp = client.index(index_name,doc_type,"1",body);
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "修改数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }
}

void search_data(elasticlient::Client& client){
    //按照测试函数的顺序执行这几个测试函数，会因为请求过快而查不到对应数据
    std::string query = R"({"query": {"match_all": {}}})";
    auto resp = client.search(index_name,doc_type,query);
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "搜索数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }else{
        std::cout << "搜索结果:" << resp.text << std::endl;
    }
}

void remove_data(elasticlient::Client& client){
    auto resp = client.remove(index_name,doc_type,"1");
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "删除数据失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }
}

void remove_index(elasticlient::Client& client){
    auto resp = client.performRequest(elasticlient::Client::HTTPMethod::DELETE,index_name,"");
    if(resp.status_code < 200 || resp.status_code >= 300){
        std::cerr << "删除索引失败,响应码:" << resp.status_code << ",响应信息:" << resp.text << std::endl;
    }
}

int main(){
    //设置服务端访问url
    const std::string url = "http://elastic:123456@192.168.30.128:9200/";//记得一定要加上最后的/不然会报错
    //创建elasticlient客户端
    elasticlient::Client client({url});
    //测试
    add_index(client);//如果存在会创建失败
    add_data(client);
    mod_data(client);
    search_data(client);
    remove_data(client);
    remove_index(client);
    return 0;
}

编译运行:

xxxxxxxxxx
source:source.cc
    g++ -std=c++17 $^ -o $@ -lcpr -ljsoncpp -lelasticlient
clean:
    rm -f source

1.6二次封装

对于ES的操作其实都是通过resful⻛格API实现的，⽽在代码中我们更多是组织出合适的json格式的正⽂，⽽如果使⽤json来进⾏组织，则要求使⽤⼈员对ES各项请求的格式与字段都有深⼊了解才⾏，为了简化使⽤要求，我们的⽬标就是封装出⼀套类能够直接序列化出指定功能的json正⽂。 ES中的操作⽆⾮也就是数据的增删改查操作，我们要做的就是将这些操作中所⽤到的json结构定义出来。 具体要搞出来的结构如下: 其实就是按照我们上面的使用样例的格式走的，因为我们index的分词器设置也就只有设置一个中文分词器而已，所以我们就不搞那么复杂了，具体封装如下:

xxxxxxxxxx
#pragma once
#include "limeutil.h"
#include "limelog.h"
#include <unordered_map>
#include <cpr/response.h>
#include <elasticlient/client.h>
#include <iostream>
#include <optional>

namespace limeelastic {
    class Base
    {
        public:
            using Ptr = std::shared_ptr<Base>;
            Base(const std::string& key);
            template<typename T>
            void add(const std::string& key, const T& value)//键值对类型数据
            {
                _value[key] = value;
            }
            template<typename T>
            void append(const std::string& key,const T& value)//数组类型数据
            {
                _value[key].append(value);
            }
            virtual std::string to_string();//将对象转化为json字符串
            const std::string& get_key() const;//获取当前对象存储值的名称
            virtual const Json::Value get_value() const;//获取当前对象存储的值
        protected:
            std::string _key;//当前对象存储值的名称
            Json::Value _value;//当前对象存储的值
    };

    class Array;
    class Object : public Base
    {
        public:
            using Ptr = std::shared_ptr<Object>;
            Object(const std::string& key);
            void addElement(const Base::Ptr& element);
            std::shared_ptr<Object> newObject(const std::string& key);
            std::shared_ptr<Array> newArray(const std::string& key);
            template<typename T>
            std::shared_ptr<T> getElement(const std::string& key)
            {
                auto it = _elements.find(key);
                if (it!= _elements.end()) {
                    //使用dynamic_pointer_cast向下安全转换类型,仅适用于shared_ptr与weak_ptr
                    return std::dynamic_pointer_cast<T>(it->second);
                }
                return nullptr;
            }
            const Json::Value get_value() const;
            std::string to_string() const;
        private:
            std::unordered_map<std::string, Base::Ptr> _elements;
    };

    class Array : public Base
    {
        public:
            using Ptr = std::shared_ptr<Array>;
            Array(const std::string& key);
            void addElement(const Base::Ptr& element);
            std::shared_ptr<Object> newObject(const std::string& key);
            std::shared_ptr<Array> newArray(const std::string& key);
            const Json::Value get_value() const;
            std::string to_string() const;
        private:
            std::vector<Base::Ptr> _elements;
    };

    class Tokenizer : public Object{
        public:
            using Ptr = std::shared_ptr<Tokenizer>;
            Tokenizer(const std::string& key);
            void setTokenizer(const std::string& tokenizer);//设定分词器
            void setType(const std::string& type);//设定分词类型
    };

    class Analyzer : public Object{
        public:
            using Ptr = std::shared_ptr<Analyzer>;
            Analyzer();
            Tokenizer::Ptr setTokenizer(const std::string& tokenizer);
    };

    class Analysis : public Object{
        public:
            using Ptr = std::shared_ptr<Analysis>;
            Analysis();
            Analyzer::Ptr setAnalyzer();
    };

    class Settings : public Object{
        public:
            using Ptr = std::shared_ptr<Settings>;
            Settings();
            Analysis::Ptr setAnalysis();
    };

    class Field : public Object{
        public:
            using Ptr = std::shared_ptr<Field>;
            Field(const std::string& key);
            void setType(const std::string& type);//设置字段类型
            void setIndex(bool index);//设置是否索引
            void setBoost(double boost);//设置权重
            void setAnalyzer(const std::string& analyzer);//设置分词器
            void setFormat(const std::string& format);//设置格式化器-对于日期这类的特殊字段
    };

    class Properties : public Object{
        public:
            using Ptr = std::shared_ptr<Properties>;
            Properties();
            Field::Ptr addField(const std::string& key);
    };

    class Mappings : public Object{
        public:
            using Ptr = std::shared_ptr<Mappings>;
            Mappings();
            void setDynamic(bool dynamic);//设置是否动态映射
            Properties::Ptr setProperties();
    };

    class Term : public Object{
        public:
            using Ptr = std::shared_ptr<Term>;
            Term(const std::string& field_name);
            template<typename T>
            void setValue(const T& value)
            {
                this->add(_field_name, value);
            }//设置查询值
        private:
            std::string _field_name;
    };

    class Terms : public Object{
        public:
            using Ptr = std::shared_ptr<Terms>;
            Terms(const std::string& field_name);
            void addValue(const std::string& value)
            {
                this->append(_field_name, value);
            }//添加查询值
        private:
            std::string _field_name;
    };

    class Match : public Object{
        public:
            using Ptr = std::shared_ptr<Match>;
            Match(const std::string& field_name);
            template<typename T>
            void setValue(const T& value)
            {
                this->add(_field_name, value);
            }//设置查询值
        private:
            std::string _field_name;
    };

    class MultiMatch : public Object{
        public:
            using Ptr = std::shared_ptr<MultiMatch>;
            MultiMatch();
            void addField(const std::string& field_name);//追加查询字段
            template<typename T>
            void setQuery(const T& query)
            {
                this->add("query", query);
            }//设置查询语句
    };

    class Range : public Object{
        public:
            using Ptr = std::shared_ptr<Range>;
            Range(const std::string& field_name);
            template<typename T>
            void setRange(const T& gte, const T& lte)
            {
                _sub->add("gte", gte);
                _sub->add("lte", lte);
            }//设置区间
        private:
            Object::Ptr _sub;
    };

    //查询操作的基础类
    class QObject : public Object{
        public:
            using Ptr = std::shared_ptr<QObject>;
            QObject(const std::string& key);
            Term::Ptr term(const std::string& field_name);//单字段精确匹配
            Terms::Ptr terms(const std::string& field_name);//多字段精确匹配
            Match::Ptr match(const std::string& field_name);//单字段模糊匹配
            MultiMatch::Ptr multi_match();//多字段模糊匹配
            Range::Ptr range(const std::string& field_name);//数字字段区间匹配
    };

    class QArray : public Array{
        public:
            using Ptr = std::shared_ptr<QArray>;
            QArray(const std::string& key);
            Term::Ptr term(const std::string& field_name);//单字段精确匹配
            Terms::Ptr terms(const std::string& field_name);//多字段精确匹配
            Match::Ptr match(const std::string& field_name);//单字段模糊匹配
            MultiMatch::Ptr multi_match();//多字段模糊匹配
            Range::Ptr range(const std::string& field_name);//数字字段区间匹配
        private:
            std::string _key;
    };

    class Must : public QArray{
        public:
            using Ptr = std::shared_ptr<Must>;
            Must();
    };

    class Should : public QArray{
        public:
            using Ptr = std::shared_ptr<Should>;
            Should();
    };

    class MustNot : public QArray{
        public:
            using Ptr = std::shared_ptr<MustNot>;
            MustNot();
    };

    class BoolQuery : public QObject{
        public:
            using Ptr = std::shared_ptr<BoolQuery>;
            BoolQuery();
            void minimum_should_match(int num);
            Must::Ptr setMust();
            Should::Ptr setShould();
            MustNot::Ptr setMustNot();
    };

    class Query : public QObject{
        public:
            using Ptr = std::shared_ptr<Query>;
            Query();
            void match_all();
            BoolQuery::Ptr setBoolQuery();
            Must::Ptr setMust();
            Should::Ptr setShould();
            MustNot::Ptr setMustNot();
    };

    class Request {
        public:
            Request(const std::string &index, const std::string &type, const std::string &op, const std::string &id);
            void set_index(const std::string &index);
            void set_type(const std::string &type);
            void set_op(const std::string &op);
            void set_id(const std::string &id);
            const std::string& get_index() const;
            const std::string& get_type() const;
            const std::string& get_op() const;
            const std::string& get_id() const;
        protected:
            std::string _index;
            std::string _type;
            std::string _op;
            std::string _id;
    };

    class Indexer : public Object,public Request{
        public:
            using Ptr = std::shared_ptr<Indexer>;
            Indexer(const std::string &index);
            Settings::Ptr setSettings();
            Tokenizer::Ptr setTokenizer(const std::string& tokenizer);//设定分词器
            Mappings::Ptr setMappings();
            Field::Ptr addField(const std::string& key);//添加字段
    };

    class Inserter : public Object, public Request {
        public:
            using ptr = std::shared_ptr<Inserter>;
            Inserter(const std::string &index, const std::string &id);
    };

    class Updater : public Object, public Request {
        public:
            using ptr = std::shared_ptr<Updater>;
            Updater(const std::string &index, const std::string &id);
            Object::Ptr doc();
    };

    class Deleter : public Object, public Request {
        public:
            using ptr = std::shared_ptr<Deleter>;
            Deleter(const std::string &index, const std::string &id);
    };

    class Searcher: public QObject, public Request{
        public:
            using Ptr = std::shared_ptr<Searcher>;
            Searcher(const std::string &index);
            Query::Ptr setQuery();
            void size(size_t count);
            void from(size_t offest);
            void addSort(const std::string& field_name, bool asc = true);
    };

    class BaseClinet{
        public:
            using Ptr = std::shared_ptr<BaseClinet>;
            BaseClinet() = default;
            virtual ~BaseClinet() = default;
            virtual bool addIndex(const Indexer& indexer) = 0;
            virtual bool addData(const Inserter& inserter) = 0;
            virtual bool updateData(const Updater& updater) = 0;
            virtual bool deleteData(const Deleter& deleter) = 0;
            virtual bool deleteIndex(const std::string& index) = 0;
            virtual std::optional<Json::Value> searchData(const Searcher& searcher) = 0;
    };

    class EscClient : public BaseClinet{
        public:
            using Ptr = std::shared_ptr<EscClient>;
            EscClient(const std::vector<std::string>& hosts);
            bool addIndex(const Indexer& indexer) override;
            bool addData(const Inserter& inserter) override;
            bool updateData(const Updater& updater) override;
            bool deleteData(const Deleter& deleter) override;
            bool deleteIndex(const std::string& index) override;
            std::optional<Json::Value> searchData(const Searcher& searcher) override;
        private:
            std::shared_ptr<elasticlient::Client> _client;
    };
}// namespace limeelastic

xxxxxxxxxx
#include "limeelastic.h"

namespace limeelastic {
    Base::Base(const std::string& key) :_key(key) {}

    std::string Base::to_string()
    {
        Json::Value root;
        root[_key] = _value;
        return *limeutil::LimeJson::serialize(root,true);
    }

    const std::string& Base::get_key() const
    {
        return _key;
    }

    const Json::Value Base::get_value() const
    {
        return _value;
    }

    Object::Object(const std::string& key) : Base(key) {}

    void Object::addElement(const Base::Ptr& element)
    {
        _elements[element->get_key()] = element;
    }

    std::shared_ptr<Object> Object::newObject(const std::string& key)
    {
        auto is_exist = this->getElement<Object>(key);
        if (is_exist) {
            return is_exist;
        }
        auto obj = std::make_shared<Object>(key);
        this->addElement(obj);
        return obj;
    }

    std::shared_ptr<Array> Object::newArray(const std::string& key)
    {
        auto is_exist = this->getElement<Array>(key);
        if (is_exist) {
            return is_exist;
        }
        auto arr = std::make_shared<Array>(key);
        this->addElement(arr);
        return arr;
    }

    const Json::Value Object::get_value() const
    {
        Json::Value root = _value;
        for (auto& element : _elements) {
            root[element.first] = element.second->get_value();
        }
        return root;
    }

    std::string Object::to_string() const
    {
        Json::Value root = _value;//当前对象存储的值
        for (auto& element : _elements) {//子对象存储的值
            root[element.first] = element.second->get_value();
        }
        return *limeutil::LimeJson::serialize(root,true);
    }

    Array::Array(const std::string& key) : Base(key) {}

    void Array::addElement(const Base::Ptr& element)
    {
        _elements.push_back(element);
    }

    std::shared_ptr<Object> Array::newObject(const std::string& key)
    {
        //这里不管原本是否存在目标元素，添加重复了是使用者的问题
        auto obj = std::make_shared<Object>(key);
        this->addElement(obj);
        return obj;
    }

    std::shared_ptr<Array> Array::newArray(const std::string& key)
    {
        //这里不管原本是否存在目标元素，添加重复了是使用者的问题
        auto arr = std::make_shared<Array>(key);
        this->addElement(arr);
        return arr;
    }

    const Json::Value Array::get_value() const
    {
        Json::Value root = _value;
        for (auto& element : _elements) {
            root.append(element->get_value());
        }
        return root;
    }

    std::string Array::to_string() const
    {
        Json::Value root = _value;
        for (auto& element : _elements) {
            root.append(element->get_value());
        }
        return *limeutil::LimeJson::serialize(root,true);
    }

    Tokenizer::Tokenizer(const std::string& key) : Object(key) {
        this->setTokenizer("ik_max_word");//默认设置
        this->setType("custom");
    }

    void Tokenizer::setTokenizer(const std::string& tokenizer)
    {
        this->add("tokenizer", tokenizer);
    }

    void Tokenizer::setType(const std::string& type)
    {
        this->add("type", type);
    }

    Analyzer::Analyzer() : Object("analyzer") {}

    Tokenizer::Ptr Analyzer::setTokenizer(const std::string& tokenizer)
    {
        auto is_exist = this->getElement<Tokenizer>("tokenizer");
        if (is_exist) {
            return is_exist;
        }
        auto tokenizer_obj = std::make_shared<Tokenizer>(tokenizer);
        this->addElement(tokenizer_obj);
        return tokenizer_obj;
    }

    Analysis::Analysis() : Object("analysis") {}

    Analyzer::Ptr Analysis::setAnalyzer()
    {
        auto is_exist = this->getElement<Analyzer>("analyzer");
        if (is_exist) {
            return is_exist;
        }
        auto analyzer_obj = std::make_shared<Analyzer>();
        this->addElement(analyzer_obj);
        return analyzer_obj;
    }

    Settings::Settings() : Object("settings") {}

    Analysis::Ptr Settings::setAnalysis()
    {
        auto is_exist = this->getElement<Analysis>("analysis");
        if (is_exist) {
            return is_exist;
        }
        auto analysis_obj = std::make_shared<Analysis>();
        this->addElement(analysis_obj);
        return analysis_obj;
    }

    Field::Field(const std::string& key) : Object(key) {
        this->setType("text");//默认设置字段类型为text
    }

    void Field::setType(const std::string& type)
    {
        this->add("type", type);
    }

    void Field::setIndex(bool index)
    {
        this->add("index", index);
    }

    void Field::setBoost(double boost)
    {
        this->add("boost", boost);
    }

    void Field::setAnalyzer(const std::string& analyzer)
    {
        this->add("analyzer", analyzer);
    }

    void Field::setFormat(const std::string& format)
    {
        this->add("format", format);
    }

    Properties::Properties() : Object("properties") {}

    Field::Ptr Properties::addField(const std::string& key)
    {
        //对字段进行查找，如果存在则不添加
        auto is_exist = this->getElement<Field>(key);
        if (is_exist) {
            return is_exist;
        }
        auto field_obj = std::make_shared<Field>(key);
        this->addElement(field_obj);
        return field_obj;
    }

    Mappings::Mappings() : Object("mappings") {}

    void Mappings::setDynamic(bool dynamic)
    {
        this->add("dynamic", dynamic);
    }

    Properties::Ptr Mappings::setProperties()
    {
        auto is_exist = this->getElement<Properties>("properties");
        if (is_exist) {
            return is_exist;
        }
        auto properties_obj = std::make_shared<Properties>();
        this->addElement(properties_obj);
        return properties_obj;
    }

    Term::Term(const std::string& field_name) 
        : Object("term")
        , _field_name(field_name)
    {}

    Terms::Terms(const std::string& field_name) 
        : Object("terms")
        , _field_name(field_name)
    {}

    Match::Match(const std::string& field_name) 
        : Object("match")
        , _field_name(field_name)
    {}

    MultiMatch::MultiMatch()
        : Object("multi_match")
    {}

    void MultiMatch::addField(const std::string& field_name)
    {
        this->append("fields", field_name);
    }

    Range::Range(const std::string& field_name) 
        : Object("range")
    {
        _sub = std::make_shared<Object>(field_name);
        this->addElement(_sub);
    }

    QObject::QObject(const std::string& key) : Object(key) {}

    Term::Ptr QObject::term(const std::string& field_name)
    {
        auto is_exist = this->getElement<Term>("term");
        if (is_exist) {
            return is_exist;
        }
        auto term_obj = std::make_shared<Term>(field_name);
        this->addElement(term_obj);
        return term_obj;
    }

    Terms::Ptr QObject::terms(const std::string& field_name)
    {
        auto is_exist = this->getElement<Terms>("terms");
        if (is_exist) {
            return is_exist;
        }
        auto terms_obj = std::make_shared<Terms>(field_name);
        this->addElement(terms_obj);
        return terms_obj;
    }

    Match::Ptr QObject::match(const std::string& field_name)
    {
        auto is_exist = this->getElement<Match>("match");
        if (is_exist) {
            return is_exist;
        }
        auto match_obj = std::make_shared<Match>(field_name);
        this->addElement(match_obj);
        return match_obj;
    }

    MultiMatch::Ptr QObject::multi_match()
    {
        auto is_exist = this->getElement<MultiMatch>("multi_match");
        if (is_exist) {
            return is_exist;
        }
        auto multi_match_obj = std::make_shared<MultiMatch>();
        this->addElement(multi_match_obj);
        return multi_match_obj;
    }

    Range::Ptr QObject::range(const std::string& field_name)
    {
        auto is_exist = this->getElement<Range>("range");
        if (is_exist) {
            return is_exist;
        }
        auto range_obj = std::make_shared<Range>(field_name);
        this->addElement(range_obj);
        return range_obj;
    }

    QArray::QArray(const std::string& key)
        : Array(key)
        , _key(key)
    {}

    Term::Ptr QArray::term(const std::string& field_name)
    {
        //不考虑重复添加
        auto term_obj = std::make_shared<Term>(field_name);
        auto obj = this->newObject("");
        obj->addElement(term_obj);
        return term_obj;
    }

    Terms::Ptr QArray::terms(const std::string& field_name)
    {
        //不考虑重复添加
        auto terms_obj = std::make_shared<Terms>(field_name);
        auto obj = this->newObject("");
        obj->addElement(terms_obj);
        return terms_obj;
    }

    Match::Ptr QArray::match(const std::string& field_name)
    {
        //不考虑重复添加
        auto match_obj = std::make_shared<Match>(field_name);
        auto obj = this->newObject("");
        obj->addElement(match_obj);
        return match_obj;
    }

    MultiMatch::Ptr QArray::multi_match()
    {
        //不考虑重复添加
        auto multi_match_obj = std::make_shared<MultiMatch>();
        auto obj = this->newObject("");
        obj->addElement(multi_match_obj);
        return multi_match_obj;
    }

    Range::Ptr QArray::range(const std::string& field_name)
    {
        //不考虑重复添加
        auto range_obj = std::make_shared<Range>(field_name);
        auto obj = this->newObject("");
        obj->addElement(range_obj);
        return range_obj;
    }

    Must::Must() : QArray("must") {}

    Should::Should() : QArray("should") {}

    MustNot::MustNot() : QArray("must_not") {}

    BoolQuery::BoolQuery() : QObject("bool") {}

    void BoolQuery::minimum_should_match(int num)
    {
        this->add("minimum_should_match", num);
    }

    Must::Ptr BoolQuery::setMust()
    {
        auto is_exist = this->getElement<Must>("must");
        if (is_exist) {
            return is_exist;
        }
        auto must_obj = std::make_shared<Must>();
        this->addElement(must_obj);
        return must_obj;
    }

    Should::Ptr BoolQuery::setShould()
    {
        auto is_exist = this->getElement<Should>("should");
        if (is_exist) {
            return is_exist;
        }
        auto should_obj = std::make_shared<Should>();
        this->addElement(should_obj);
        return should_obj;
    }

    MustNot::Ptr BoolQuery::setMustNot()
    {
        auto is_exist = this->getElement<MustNot>("must_not");
        if (is_exist) {
            return is_exist;
        }
        auto must_not_obj = std::make_shared<MustNot>();
        this->addElement(must_not_obj);
        return must_not_obj;
    }

    Query::Query() : QObject("query") {}

    void Query::match_all()
    {
        this->add("match_all",Json::Value(Json::ValueType::objectValue));
    }

    BoolQuery::Ptr Query::setBoolQuery()
    {
        auto is_exist = this->getElement<BoolQuery>("bool");
        if (is_exist) {
            return is_exist;
        }
        auto bool_obj = std::make_shared<BoolQuery>();
        this->addElement(bool_obj);
        return bool_obj;
    }

    Must::Ptr Query::setMust()
    {
        auto is_exist = this->getElement<Must>("must");
        if (is_exist) {
            return is_exist;
        }
        auto must_obj = std::make_shared<Must>();
        this->addElement(must_obj);
        return must_obj;
    }

    Should::Ptr Query::setShould()
    {
        auto is_exist = this->getElement<Should>("should");
        if (is_exist) {
            return is_exist;
        }
        auto should_obj = std::make_shared<Should>();
        this->addElement(should_obj);
        return should_obj;
    }

    MustNot::Ptr Query::setMustNot()
    {
        auto is_exist = this->getElement<MustNot>("must_not");
        if (is_exist) {
            return is_exist;
        }
        auto must_not_obj = std::make_shared<MustNot>();
        this->addElement(must_not_obj);
        return must_not_obj;
    }

    Request::Request(const std::string &index, const std::string &type, const std::string &op, const std::string &id)
        : _index(index)
        , _type(type)
        , _op(op)
        , _id(id)
    {}

    void Request::set_index(const std::string &index) { _index = index; };

    void Request::set_type(const std::string &type) { _type = type; };

    void Request::set_op(const std::string &op) { _op = op; };

    void Request::set_id(const std::string &id) { _id = id; };

    const std::string& Request::get_index() const { return _index; };

    const std::string& Request::get_type() const { return _type; };

    const std::string& Request::get_op() const { return _op; };

    const std::string& Request::get_id() const { return _id; };

    Indexer::Indexer(const std::string &index) 
        : Object("")
        , Request(index, "_doc", "_index", index)
    {}

    Settings::Ptr Indexer::setSettings()
    {
        auto is_exist = this->getElement<Settings>("settings");
        if (is_exist) {
            return is_exist;
        }
        auto settings_obj = std::make_shared<Settings>();
        this->addElement(settings_obj);
        return settings_obj;
    }

    Tokenizer::Ptr Indexer::setTokenizer(const std::string& tokenizer)
    {
        return this->setSettings()->setAnalysis()->setAnalyzer()->setTokenizer(tokenizer);
    }

    Mappings::Ptr Indexer::setMappings()
    {
        auto is_exist = this->getElement<Mappings>("mappings");
        if (is_exist) {
            return is_exist;
        }
        auto mappings_obj = std::make_shared<Mappings>();
        this->addElement(mappings_obj);
        return mappings_obj;
    }

    Field::Ptr Indexer::addField(const std::string& key)
    {
        return this->setMappings()->setProperties()->addField(key);
    }

    Inserter::Inserter(const std::string &index, const std::string &id)
        : Object("")
        , Request(index, "_doc", "_insert", id)
    {}

    Updater::Updater(const std::string &index, const std::string &id)
        : Object("")
        , Request(index, "_doc", "_update", id)
    {}

    Object::Ptr Updater::doc()
    {
        auto is_exist = this->getElement<Object>("doc");
        if (is_exist) {
            return is_exist;
        }
        auto doc_obj = std::make_shared<Object>("doc");
        this->addElement(doc_obj);
        return doc_obj;
    }

    Deleter::Deleter(const std::string &index, const std::string &id)
        : Object("")
        , Request(index, "_doc", "_delete", id)
    {}

    Searcher::Searcher(const std::string &index) 
        : QObject("")
        , Request(index, "_doc", "_search", "")
    {}

    Query::Ptr Searcher::setQuery()
    {
        auto is_exist = this->getElement<Query>("query");
        if (is_exist) {
            return is_exist;
        }
        auto query_obj = std::make_shared<Query>();
        this->addElement(query_obj);
        return query_obj;
    }

    void Searcher::size(size_t count) {
        this->add("size", count);
    }

    void Searcher::from(size_t offset) {
        this->add("from", offset);
    }

    void Searcher::addSort(const std::string& field_name, bool asc) {
        Json::Value sort_obj;
        sort_obj[field_name] = asc ? "asc" : "desc";
        this->append("sort", sort_obj);//重复添加排序规则是使用者的问题
    }

    EscClient::EscClient(const std::vector<std::string>& hosts)
        : _client(std::make_shared<elasticlient::Client>(hosts))
    {}

    bool EscClient::addIndex(const Indexer& indexer)
    {
        std::string index_name = indexer.get_index();
        std::string body = indexer.to_string();
        auto resp = _client->performRequest(elasticlient::Client::HTTPMethod::PUT,index_name,body);
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("创建索引失败,响应码:{},响应信息:{}", resp.status_code, resp.text);
            return false;
        }
        return true;
    }

    bool EscClient::addData(const Inserter& inserter)
    {
        std::string index_name = inserter.get_index();
        std::string doc_type = inserter.get_type();
        std::string id = inserter.get_id();
        std::string body = inserter.to_string();
        auto resp = _client->index(index_name,doc_type,id,body);
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("添加数据失败,响应码:{},响应信息:{}", resp.status_code, resp.text);
            return false;
        }
        return true;
    }

    bool EscClient::updateData(const Updater& updater)
    {
        std::string index_name = updater.get_index();
        std::string op = updater.get_op();
        std::string id = updater.get_id();
        std::string body = updater.to_string();
        std::string url = index_name + "/" + op + "/" + id;
        auto resp = _client->performRequest(elasticlient::Client::HTTPMethod::POST,url,body);
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("更新数据失败,响应码:{},响应信息:{}", resp.status_code, resp.text);
            return false;
        }
        return true;
    }

    bool EscClient::deleteData(const Deleter& deleter)
    {
        std::string index_name = deleter.get_index();
        std::string doc_type = deleter.get_type();
        std::string id = deleter.get_id();
        auto resp = _client->remove(index_name,doc_type,id);
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("删除数据失败,响应码:{},响应信息:{}", resp.status_code, resp.text);
            return false;
        }
        return true;
    }

    bool EscClient::deleteIndex(const std::string& index)
    {
        std::string index_name = index;
        auto resp = _client->performRequest(elasticlient::Client::HTTPMethod::DELETE,index_name,"");
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("删除索引失败,响应码:{},响应信息:{}", resp.status_code, resp.text);
            return false;
        }
        return true;
    }

    std::optional<Json::Value> EscClient::searchData(const Searcher& searcher)
    {
        std::string index_name = searcher.get_index();
        std::string doc_type = searcher.get_type();
        std::string body = searcher.to_string();
        auto resp = _client->search(index_name,doc_type,body);
        if(resp.status_code < 200 || resp.status_code >= 300){
            ERR("搜索数据失败,响应码:{},响应信息:{},请求正文:{}", resp.status_code, resp.text,body);
            return std::nullopt;
        }
        //解析响应数据
        auto json_resp = limeutil::LimeJson::deserialize(resp.text);
        if(!json_resp)
        {
            ERR("解析响应数据失败:{}", resp.text);
            return std::nullopt;
        }
        //获取查询结果
        if(json_resp->isNull() || (*json_resp)["hits"].isNull() || (*json_resp)["hits"]["hits"].isNull())
        {
            ERR("无法正确解析结果:{}", resp.text);
            return std::nullopt;
        }
        Json::Value result;
        int sz = (*json_resp)["hits"]["hits"].size();
        for(int i=0;i<sz;i++)
        {
            result.append((*json_resp)["hits"]["hits"][i]["_source"]);
        }
        return result;
    }
} // namespace limeelastic