Elasticsearch从入门到实践：核心概念到Kibana测试与C++客户端封装

敲上瘾2025-11-05 9:13

文章目录

概念简述

Elasticsearch，简称 ES，它是个开源分布式搜索引擎，它的特点有：分布式、零配置、自动发现、索引自动分片、索引副本机制、restful 风格接口、多数据源、自动搜索负载等。ES类似数据库，相比数据库，它在搜索功能上更为实用、高效。

在搜索上与数据库的区别？

数据库的搜索策略类似二叉搜索树，但在文本搜索场景下，只能使用like模糊匹配，效率较低。而es主要做分词搜索，比如"你好，世界"，会被分成："你"、"好"、"世"、"界"、"你好"、"世界"...

es核心概念

  • 索引：一个索引就是一个拥有几分相似特征的文档的集合，类似于mysql数据库中的库。
  • 类型：一个类型是索引的一个逻辑上的分类/分区，类似于mysql数据库中库结构下的表。
  • 字段：相当于 MySQL 数据库中的列，对文档数据根据不同属性进行的分类标识。

字段类型：

分类 类型 备注
字符串 text, keyword text会被分词生成索引；keyword不会被分词生成索引，只能精确值搜索
整形 integer, long, short, byte -
浮点 double, float -
逻辑 boolean true 或 false
日期 date, date_nanos "2018-01-13"或"2018-01-13 12:10:30"或者时间戳，即1970到现在的秒数/毫秒数
二进制 binary 二进制通常只存储，不索引
范围 range -

字符串是最常用的字段类型

提示：es中的类型基本上已经被弃用，通常是一个es索引管理一种数据。

映射

它定义了每条数据记录（文档）中的每个字段（Field）应该是什么类型，以及应该如何被处理，对数据的处理方式和规则做一些限制。

比如该字段是否做搜索分析，比如我们在搜索好友时不会通过性别或个性签名去搜索到好友，所以这些字段不用做搜索分析。（通过enabled设置）

又或者在音乐软件上做搜索，那么用户想搜的不一定是歌名，也可以把歌手，用户名，歌词等等进行搜索分析，而我们可以为这些字段设置权重，把歌名做最高权重，然后依次根据需要做不同权重。（通过boost设置）

这就是映射的意义与重要性，如下es的 映射参数：

名称 数值 备注
enabled true(默认) | false 是否仅作存储，不做搜索和分析
index true(默认) | false 是否构建倒排索引（决定了是否分词，是否被索引）
index_option - -
dynamic true（缺省）| false 控制 mapping 的自动更新
doc_value true(默认) | false 是否开启 doc_value，用于聚合和排序分析，分词字段不能使用
fielddata "fielddata": {"format": "disabled"} 是否为 text 类型启动 fielddata，实现排序和聚合分析针对分词字段，参与排序或聚合时能提高性能，不分词字段统一建议使用 doc_value
store true | false(默认) 是否单独设置此字段的是否存储而从_source 字段中分离，只能搜索，不能获取值
coerce true(默认) | false 是否开启自动数据类型转换功能，比如：字符串转数字，浮点转整型
analyzer "analyzer":"ik" 指定分词器，默认分词器为 standard analyzer
boost "boost": 1.23 字段级别的分数加权，默认值是 1.0
fields "fields": { "raw": { "type": "text", "index": "not_analyzed" } } 对一个字段提供多种索引模式，同一个字段的值可对应两种索引模式，一种分词索引，一种不分词索引
data_detection true(默认) | false 是否自动识别日期类型

安装与配置

复制代码 
# 添加仓库秘钥
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch |
sudo apt-key add -
# 上边的添加方式会导致一个 apt-key 的警告，如果不想报警告使用下边这个
curl -s https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo
gpg --no-default-keyring --keyring gnupgring:/etc/apt/trusted.gpg.d/icsearch.gpg --import
# 添加镜像源仓库
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable
main" | sudo tee /etc/apt/sources.list.d/elasticsearch.list
# 更新软件包列表
sudo apt update
# 安装 es
sudo apt-get install elasticsearch=7.17.21
# 启动 es
sudo systemctl start elasticsearch
# 安装 ik 分词器插件
sudo /usr/share/elasticsearch/bin/elasticsearch-plugin install
https://get.infini.cloud/elasticsearch/analysis-ik/7.17.21

启动es

bash 复制代码 
sudo systemctl start elasticsearch

配置外网访问

复制代码 
vim /etc/elasticsearch/elasticsearch.yml
# 新增配置
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: ["node-1"]

Kibana 是 Elastic Stack 技术栈中的一个开源数据分析与可视化平台。它作为一个基于 Web 的图形界面，为用户提供了对存储在 Elasticsearch 中的数据进行探索、可视化、交互和管理的能力。

安装 Kibana：

复制代码 
#使用 apt 命令安装 Kibana。
sudo apt install kibana
#配置 Kibana（可选）：
#根据需要配置 Kibana。配置文件通常位于 /etc/kibana/kibana.yml。可能需要
#设置如服务器地址、端口、 Elasticsearch URL 等。
sudo vim /etc/kibana/kibana.yml
#例如，你可能需要设置 Elasticsearch 服务的 URL： 大概 32 行左右
elasticsearch.host: "http://localhost:9200"
#启动 Kibana 服务：
#安装完成后，启动 Kibana 服务。
sudo systemctl start kibana
#设置开机自启（可选）：
#如果你希望 Kibana 在系统启动时自动启动，可以使用以下命令来启用自启动。
sudo systemctl enable kibana
#验证安装：
#使用以下命令检查 Kibana 服务的状态。
sudo systemctl status kibana
#访问 Kibana：
#在浏览器中访问 Kibana，通常是 http://<your-ip>:5601

测试示例

通过网页访问Kibana

json 复制代码 
POST /user/_doc
{
    "settings" : {
        "analysis" : {
            "analyzer" : {
                "ik" : {
                    "tokenizer" : "ik_max_word"
                }
            }
        }
    },
    "mappings" : {
        "dynamic" : true,
        "properties" : {
            "昵称" : {
                "type" : "text",
                "analyzer" : "ik_max_word"
            },
            "用户ID" : {
                "type" : "keyword",
                "analyzer" : "standard"
            },
            "手机号" : {
                "type" : "keyword",
                "analyzer" : "standard"
            },
            "描述" : {
                "type" : "text",
                "enabled" : false
            },
            "头像ID" : {
                "type" : "keyword",
                "enabled" : false
            }
        }
    }
}

  • post：以请求的方式提交数据

  • user：索引名称（存储用户数据的库）

  • _doc：类型（此处为文档类型标识）

  • analyzer：分词器设置，ik为中文分词器，tokenizer用于指定分词粒度，ik_max_word表示以最大的粒度进行分词。

  • mapping：表示下面要描述的映射关系

  • dynamic：true表示未定义的字段会自动添加到映射并使用默认配置

  • type

    • text：是一个文本类型
    • keyword：是一个文本类型，但是是关键字不进行分词

  • analyzer

    • standard：默认标准分词器
    • ik_max_word：中文分词器

数据插入

json 复制代码 
POST /user/_doc/_bulk
{"index":{"_id":"1"}}
{"user_id":"USER4b8a2aaa-2df8654a-7eb4bb65-e3507f66","nickname":"昵称 1","phone":"手机号1","description":"签名 1","avatar_id":"头像 1"}
{"index":{"_id":"2"}}
{"user_id":"USER14eeea5-442771b9-0262e455-e4663d1d","nickname":"昵称 2","phone":"手机号 2","description":"签名 2","avatar_id":"头像 2"}
{"index":{"_id":"3"}}
{"user_id":"USER4b8a6734-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":"USER6f1d9074-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"}

注意：每条数据需按'索引声明行 + 数据行'的格式书写，且每行需单独占一行。

数据搜索

搜索所有数据：

json 复制代码 
POST /user/_doc/_search
{
		"query": {
		"match_all":{}
		}
}

以昵称这个"关键词"进行条件搜索：

json 复制代码 
GET /user/_doc/_search?pretty
{
    "query": {
        "bool": {
            "must_not": [
                {
                    "terms": {
                        "user_id.keyword": [
                            "USER4b862aaa-2df8654a-7eb4bb65-e3597766",
                            "USER14eeeaa5-442771b9-0262e455-e4663d1d",
                            "USER484a6734-93a124f0-996c169d-d05c1869"
                        ]
                    }
                }
            ],
            "should": [
                {
                    "match": {
                        "user_id": "昵称"
                    }
                },
                {
                    "match": {
                        "nickname": "昵称"
                    }
                },
                {
                    "match": {
                        "phone": "昵称"
                    }
                }
            ]
        }
    }
}
  • must_not：描述必须不包含的项，方向搜索
  • should：描述应该遵循的条件，表示在以下任意一个字段中出现"昵称"则匹配成功。

注意：如上过滤条件中，user_id，需要加keyword，表示不进行分词。不加该字段默认是分词匹配，分词字段与不分词字段无法直接匹配。

客户端API使用

  1. 构造函数
cpp 复制代码 
explicit Client(const std::vector<std::string> &hostUrlList,
std::int32_t timeout = 6000);

该接口用于创建和初始化 Elasticsearch 客户端实例

  • hostUrlList：传入地址列表，即http://ip:port如果有多个地址，可以传入列表。
  • timeout：为连接超时时间，通常用缺省值。
  1. 查询数据
cpp 复制代码 
search(const std::string &indexName,  
const std::string &docType,  
const std::string &body,
const std::string &routing =std::string())

search接口用于在指定索引中执行搜索查询，根据查询条件返回匹配的文档列表。

  1. 创建索引和新增数据
cpp 复制代码 
index(const std::string &indexName, 
const std::string &docType,
const std::string &id, 
const std::string &body,
const std::string &routing = std::string())

index接口用于在Elasticsearch中创建索引，或新增数据和更新数据，通过指定索引名称、文档ID和内容来存储数据。

  1. 删除数据
cpp 复制代码 
remove(const std::string &indexName,
const std::string &docType,
const std::string &id,
const std::string &routing = std::string())

remove接口用于从Elasticsearch索引中删除指定ID的文档，永久移除目标数据。

关于以上三个接口的参数：

  • indexName：索引名称
  • docType：指定文档类型
  • id：用于标识一个索引内键值的唯一性
  • body：正文部分，用于创建索引、搜索或添加数据的JSON 字符串
  • routing：路由键，用于控制文档存储到哪个分片，通常就用缺省值

返回值类型为 cpr::Response，通常会使用它的status_code字段（是一个状态码，用于判断函数执行是否成功）和text字段（返回的正文部分，是一个Json字符串）。

搜索接口的使用测试：

c 复制代码 
#include <elasticlient/client.h>
#include <cpr/cpr.h>
#include <iostream>
int main()
{
    elasticlient::Client client({"http://127.0.0.1:9200"});
    try{
        //注意需要在 9200 后加 / 或在 user 前面加 /，要不然会成为无效的URI
        auto ret = client.search("/user", "_doc", "{\"query\": { \"match_all\":{} }}");
        std::cout<<ret.status_code<<std::endl;
        std::cout<<ret.text<<std::endl;
    }catch(std::exception& ex){
        std::cout<<"请求失败："<<ex.what()<<std::endl;
        return -1;
    }
    return 0;
}

效果：

二次封装源码

Elasticsearch 原生 API 需要开发者手动构造复杂的 JSON 查询语句，成本高且容易出错。我们可以对它进行二次封装，通过简洁的方法链式调用完成复杂查询，大大降低使用门槛，提升开发效率。

jsoncpp序列化与反序列化,参考文章：Linux系统C++开发工具（四）------ jsoncpp 使用指南

由于索引创建、数据查询、数据删除等操作可能分布在不同服务器执行，因此将它们拆分为多个类分别实现。如下：

cpp 复制代码 
#include <elasticlient/client.h>
#include <json/json.h>
#include <cpr/cpr.h>
#include <iostream>
#include <vector>
#include "../spdlog/logger.hpp"
//序列化
bool Serialize(const Json::Value &val, std::string &out)
{
    // 通过工厂类构建StreamWriter
    auto nsw = Json::StreamWriterBuilder().newStreamWriter(); // 因为工厂类在该场景中不在使用，所以构造临时对象。
    std::stringstream ss;
    int ret = nsw->write(val, &ss);
    if (ret != 0)
    {
        std::cout << "序列化失败";
        return false;
    }
    out = ss.str();
    return true;
}
//反序列化
bool UnSerialize(const std::string &str, Json::Value &val)
{
    auto crb = Json::CharReaderBuilder().newCharReader();
    std::string erro;
    bool ret = crb->parse(str.c_str(), str.c_str() + str.size(), &val, &erro);
    if (ret == false)
    {
        std::cout << "反序列化失败" << std::endl;
        return false;
    }
    return true;
}
//创建索引
class ESIndex
{
public:
    ESIndex(const std::shared_ptr<elasticlient::Client> client,
            std::string name,
            const std::string type = "_doc")
        : _client(client), _name(name), _type(type)
    {
        Json::Value ik;
        ik["tokenizer"] = "ik_max_word";
        Json::Value analyzer;
        analyzer["ik"] = ik;
        Json::Value analysis;
        analysis["analyzer"] = analyzer;
        Json::Value settings;
        settings["analysis"] = analysis;
        _index["settings"] = settings;
    }
    ESIndex append(const std::string &key,
                const std::string &type = "text",
                const std::string &analyzer = "ik_max_word",
                bool enabled = true) // 添加字段
    {
        Json::Value data;
        data["type"] = type;
        data["analyzer"] = analyzer;
        data["enabled"] = enabled;
        _properties[key] = data;
        return *this;
    }
    bool create()
    {
        Json::Value mappings;
        mappings["dynamic"] = true;
        mappings["properties"] = _properties;
        _index["mappings"] = mappings;
        std::string body;
        Serialize(_index, body);
        try
        {
            auto ret = _client->index(_name, _type, "", body);
            if(ret.status_code<200||ret.status_code>=300)
            {
                LOG_ERR("创建索引 {} 失败",_name);
                return false;
            }
        }
        catch (std::exception &e)
        {
                LOG_ERR("创建索引 {} 失败:{}",_name,e.what());
                return false;
        }
        //std::cout << _index << std::endl;
        return true;
    }
private:
    std::string _name;
    std::string _type;
    Json::Value _properties;
    Json::Value _index;
    std::shared_ptr<elasticlient::Client> _client;
};

//插入数据
class ESInsert
{
public:
    ESInsert(const std::shared_ptr<elasticlient::Client> client,
                std::string name,
                const std::string type = "_doc")
            : _client(client), _name(name), _type(type)
    {}
    template<typename T>
    ESInsert& append(const std::string& key,const T& val)
    {
        _item[key] = val;
        return *this;
    }
    bool insert(const std::string& id = "")
    {
        std::string data;
        bool ret = Serialize(_item,data);
        if(ret == false)
            return false;
        try
        {
            auto rsp = _client->index(_name,_type,id,data);
            if(rsp.status_code < 200 || rsp.status_code >= 300)
            {
                LOG_ERR("数据插入失败：{}",rsp.status_code);
                return false;
            }
        }
        catch(std::exception& e)
        {
            LOG_ERR("数据插入失败：{}",e.what());
            return false;
        }
        return true;
    }
private:
    std::string _name;
    std::string _type;
    Json::Value _item;
    std::shared_ptr<elasticlient::Client> _client;
};

//删除数据
class ESRemove
{
public:
    ESRemove(const std::shared_ptr<elasticlient::Client> client,
                    std::string name,
                    const std::string type = "_doc")
                : _client(client), _name(name), _type(type)
    {}
    bool remove(std::string id)
    {
        try
        {
            auto rsp = _client->remove(_name,_type,id);
            if(rsp.status_code < 200 || rsp.status_code >= 300)
            {
                LOG_ERR("数据删除失败：{}",rsp.status_code);
                return false;
            }
        }
        catch(std::exception& e)
        {
            LOG_ERR("数据删除失败：{}",e.what());
            return false;
        }
        return true;
    }
private:
    std::string _name;
    std::string _type;
    std::shared_ptr<elasticlient::Client> _client;
};

//查询数据
class ESSearch
{
public:
    ESSearch(const std::shared_ptr<elasticlient::Client> client,
                    std::string name,
                    const std::string type = "_doc")
                : _client(client), _name(name), _type(type)
    {}
    ESSearch& append_must_not_terms(const std::string& key,const std::vector<std::string>& data)
    {
        Json::Value mnt;
        for(auto x:data)
            mnt[key].append(x);
        Json::Value terms;
        terms["terms"] = mnt;
        _must_not.append(terms);
        return *this;
    }
    ESSearch& append_must_terms(const std::string& key,const std::string& val)
    {
        Json::Value mt;
        mt[key]=val;
        Json::Value terms;
        terms["terms"] = mt;
        _must.append(terms);
        return *this;
    }
    ESSearch& append_must_match(const std::string& key,const std::string& val)
    {
        Json::Value mm;
        mm[key] = val;
        Json::Value match;
        match["match"] = mm;
        _must.append(match);
        return *this;
    }
    ESSearch& append_should_match(const std::string& key,const std::string& val)
    {
        Json::Value sm;
        sm[key] = val;
        Json::Value match;
        match["match"] = sm;
        _should.append(match);
        return *this;
    }
    Json::Value search()
    {
        Json::Value data;
        if(!_must_not.empty()) data["must_not"] = _must_not;
        if(!_must.empty()) data["must"] = _must;
        if(!_should.empty()) data["should"] = _should;
        Json::Value bl;
        bl["bool"] = data;
        Json::Value query;
        query["query"] = bl;
        std::string body;
        bool ret = Serialize(query,body);
        if(ret==false)
        {
            LOG_ERR("序列化失败");
            return Json::Value();
        }
        cpr::Response rsp;
        try
        {
            rsp = _client->search(_name,_type,body);
            if(rsp.status_code<200||rsp.status_code>=300)
            {
                LOG_ERR("搜索失败：{}",rsp.status_code);
                return Json::Value();
            }
        }
        catch(std::exception& e)
        {
            LOG_ERR("搜索失败：{}",e.what());
            return Json::Value();
        }
        Json::Value val;
        ret = UnSerialize(rsp.text,val);
        if(ret == false)
        {
            LOG_ERR("反序列化失败");
            return Json::Value();
        }
        return val["hits"]["hits"];
    }
private:
    std::string _name;
    std::string _type;
    Json::Value _must_not;
    Json::Value _must;
    Json::Value _should;
    std::shared_ptr<elasticlient::Client> _client;
};

非常感谢您能耐心读完这篇文章。倘若您从中有所收获，还望多多支持呀！

相关推荐
api_180079054603 小时前
请求、认证与响应数据解析：1688 商品 API 接口深度探秘
java·大数据·开发语言·mysql·数据挖掘
慕慕涵雪月光白3 小时前
在Ubuntu系统上安装英伟达（NVIDIA）RTX 3070 Ti的驱动程序
linux·运维·人工智能·ubuntu
第七序章3 小时前
【C + +】C + + 11（中）——Lambda 表达式 + 可变参数模板
c语言·c++·算法·1024程序员节
做运维的阿瑞4 小时前
CentOS 7 停止维护后 YUM 源配置速查手册
linux·运维·centos
mc23564 小时前
Linux 基本命令
linux
巴渝小禹4 小时前
【Ubuntu】ubuntu虚拟机磁盘不够扩容后开机黑屏-解决方案
linux·ubuntu
老黄编程4 小时前
08-ubuntu如何获取发行版代号
linux·运维·ubuntu
草莓熊Lotso4 小时前
Linux 权限管理进阶：从 umask 到粘滞位的深度解析
linux·运维·服务器·人工智能·ubuntu·centos·unix
0和1的舞者6 小时前
网络通信的奥秘：网络层ip与路由详解（四）
大数据·网络·计算机网络·计算机·智能路由器·计算机科学与技术
热门推荐
01GitHub 镜像站点02综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件03UV安装并设置国内源04《大数据技术原理与应用》实验报告三 熟悉HBase常用操作05npm使用国内淘宝镜像的方法06Linux下V2Ray安装配置指南07BongoCat - 跨平台键盘猫动画工具08jdk21下载、安装（Windows、Linux、macOS）09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程