mkdir -p /opt/es/data
mkdir -p /opt/es/plugins
mkdir -p /opt/es/logs

chmod -R 777 /opt/es/data
chmod -R 777 /opt/es/logs

docker pull elasticsearch:8.15.2
docker pull kibana:8.15.2

cd /mnt/d

docker save elasticsearch:8.15.2 > elasticsearch.tar
docker save kibana:8.15.2 > kibana.tar

docker load -i elasticsearch.tar
docker load -i kibana.tar

docker images

docker run -d \
--name es \
--network pub-network \
--restart always \
-p 9200:9200 \
-p 9300:9300 \
-e "xpack.security.enabled=false" \
-e "discovery.type=single-node" \
-e "http.cors.enabled=true" \
-e "http.cors.allow-origin:*" \
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
-v /opt/es/data:/usr/share/elasticsearch/data \
-v /opt/es/plugins:/usr/share/elasticsearch/plugins \
-v /opt/es/logs:/usr/share/elasticsearch/logs \
--privileged=true \
elasticsearch:8.15.2

docker run -d \
--name kibana \
--network pub-network \
--restart always \
-p 5601:5601 \
-e CSP_STRICT=false \
-e I18N_LOCALE=zh-CN \
kibana:8.15.2

  es:
    image: elasticsearch:8.15.2
    container_name: es
    network_mode: pub-network
    restart: always
    ports:
      # 9200：對(duì)外暴露的端口
      - 9200:9200
      # 9300：節(jié)點(diǎn)間通信端口
      - 9300:9300
    environment:
      # 禁用密碼登錄
      xpack.security.enabled: 'false'
      # 單節(jié)點(diǎn)運(yùn)行
      discovery.type: single-node
      # 允許跨域
      http.cors.enabled: 'true'
      # 允許所有訪問(wèn)
      http.cors.allow-origin: '*'
      # 堆內(nèi)存大小
      ES_JAVA_OPTS: '-Xms512m -Xmx512m'
    volumes:
      # 數(shù)據(jù)掛載
      - /opt/es/data:/usr/share/elasticsearch/data
      # 插件掛載
      - /opt/es/plugins:/usr/share/elasticsearch/plugins
      # 日志掛載
      - /opt/es/logs:/usr/share/elasticsearch/logs
    # 允許root用戶運(yùn)行
    privileged: true
  kibana:
    image: kibana:8.15.2
    container_name: kibana
    network_mode: pub-network
    restart: always
    ports:
      - 5601:5601
    environment:
      # 禁用安全檢查
      CSP_STRICT: 'false'
      # 設(shè)置中文
      I18N_LOCALE: zh-CN
networks:
  pub-network:
    name: pub-network

docker-compose up -d

docker rm -f es
docker rm -f kibana

# 生成密碼
docker exec -it es /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic
# 生成kibana訪問(wèn)token
docker exec -it es /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana

docker logs kibana

GET /_analyze
{
  "analyzer": "ik_max_word",
  "text": "好好學(xué)習(xí)天天向上"
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 擴(kuò)展配置</comment>
	<!--用戶可以在這里配置自己的擴(kuò)展字典 -->
	<entry key="ext_dict">ext.dic</entry>
	 <!--用戶可以在這里配置自己的擴(kuò)展停止詞字典-->
	<entry key="ext_stopwords">stopword.dic</entry>
	<!--用戶可以在這里配置遠(yuǎn)程擴(kuò)展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用戶可以在這里配置遠(yuǎn)程擴(kuò)展停止詞字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 擴(kuò)展配置</comment>
	<!--用戶可以在這里配置自己的擴(kuò)展字典 -->
	<entry key="ext_stopwords">stopword.dic</entry>
</properties>

vim /opt/es/plugins/elasticsearch-analysis-ik-8.15.2/config/IKAnalyzer.cfg.xml

touch /opt/es/plugins/elasticsearch-analysis-ik-8.15.2/config/ext.dic

vim /opt/es/plugins/elasticsearch-analysis-ik-8.15.2/config/ext.dic

vim /opt/es/plugins/elasticsearch-analysis-ik-8.15.2/config/stopword.dic

docker restart es

GET /_analyze{  "analyzer": "ik_max_word",  "text": "重重的鋁坨坨"}

PUT /mgr
{
  "mappings": {
    "properties": {
      "info": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email": {
        "type": "keyword",
        "index": false
      },
      "name": {
        "type": "object",
        "properties": {
          "firstName": {
            "type": "keyword"
          },
          "lastName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

GET /mgr

PUT /mgr/_mapping
{
  "properties":{
    "age":{
      "type":"integer"
    }
  }
}

DELETE /mgr

POST /mgr/_doc/1
{
  "info": "鋁坨坨鍵盤",
  "email": "11111@gmail.com",
  "name": {
    "firstName": "C",
    "lastName": "I"
  }
}

GET /mgr/_doc/1

PUT /mgr/_doc/1
{
  "info": "鋁坨坨鍵盤",
  "email": "222@gmail.com",
  "name": {
    "firstName": "C",
    "lastName": "I"
  }
}

POST /mgr/_update/1{  "doc": {    "email": "333@gmail.com"  }}

DELETE /mgr/_doc/1

elasticsearch = "8.15.0-alpha.1"
# 序列化和反序列化數(shù)據(jù)
serde = { version = "1.0.127", features = ["derive"] }
# 序列化JSON
serde_json = "1.0.128"
tokio = { version = "1", features = ["full"] }
# 異步鎖
once_cell = "1.20.2"

# 指定當(dāng)前配置文件
RUN_MODE=development

debug = true
# 指定開(kāi)發(fā)環(huán)境配置
profile = "development"
[es]
host = "127.0.0.1"

use serde::Deserialize;
#[derive(Debug, Deserialize, Clone)]
pub struct EsConfig {
    host: String,
    port: u16,
}
impl EsConfig {
    // 獲取redis連接地址
    pub fn get_url(&self) -> String {
        format!("http://{host}:{port}", host = self.host, port = self.port)
    }
}

#[derive(Debug, Deserialize, Clone)]
pub struct AppConfig {
    pub es:EsConfig,
}
impl AppConfig {
    pub fn read(env_src: Environment) -> Result<Self, config::ConfigError> {
        // 獲取配置文件目錄
        let config_dir = get_settings_dir()?;
        info!("config_dir: {:#?}", config_dir);
        // 獲取配置文件環(huán)境
        let run_mode = std::env::var("RUN_MODE")
            .map(|env| Profile::from_str(&env).map_err(|e| ConfigError::Message(e.to_string())))
            .unwrap_or_else(|_e| Ok(Profile::Dev))?;
        // 當(dāng)前配置文件名
        let profile_filename = format!("{run_mode}.toml");
        // 獲取配置
        let config = config::Config::builder()
            // 添加默認(rèn)配置
            .add_source(config::File::from(config_dir.join("default.toml")))
            // 添加自定義前綴配置
            .add_source(config::File::from(config_dir.join(profile_filename)))
            // 添加環(huán)境變量
            .add_source(env_src)
            .build()?;
        info!("Successfully read config profile: {run_mode}.");
        // 反序列化
        config.try_deserialize()
    }
}
// 獲取配置文件目錄
pub fn get_settings_dir() -> Result<std::path::PathBuf, ConfigError> {
    Ok(get_project_root()
        .map_err(|e| ConfigError::Message(e.to_string()))?
        .join("settings"))
}
#[cfg(test)]
mod tests {
    use crate::config::profile::Profile;
    use self::env::get_env_source;
    pub use super::*;
    #[test]
    pub fn test_profile_to_string() {
        // 設(shè)置dev模式
        let profile: Profile = Profile::try_from("development").unwrap();
        println!("profile: {:#?}", profile);
        assert_eq!(profile, Profile::Dev)
    }
    #[test]
    pub fn test_read_app_config_prefix() {
        // 讀取配置
        let config = AppConfig::read(get_env_source("APP")).unwrap();
        println!("config: {:#?}", config);
    }
}

// 環(huán)境變量前綴
pub const ENV_PREFIX: &str = "APP";
// 配置
pub static CONFIG: Lazy<crate::config::AppConfig> = Lazy::new(||
    crate::config::AppConfig::read(get_env_source(ENV_PREFIX)).unwrap()
);

use crate::config::AppConfig;
// 傳輸配置文件到客戶端
pub trait ClientBuilder: Sized {
    fn build_from_config(config: &AppConfig) -> Result<Self,InfraError>;
}

// 類型別名
pub type EsClient = Arc<Elasticsearch>;
// 加載配置文件
pub trait EsClientExt: Sized {
    fn build_from_config(config: &AppConfig) -> impl Future<Output = Result<Self, InfraError>>;
}
impl EsClientExt for EsClient {
    async fn build_from_config(config: &AppConfig) -> Result<Self, InfraError> {
        // 1、使用single_node方式創(chuàng)建client
        // let transport = Transport::single_node(&config.es.get_url()).unwrap();
        // let client = Elasticsearch::new(transport);
        // Ok(Arc::new(client))
        // 2、使用builder方式創(chuàng)建client，可以添加多個(gè)url
        let url = config.es.get_url();
        let url_parsed = url
            .parse::<elasticsearch::http::Url>()
            .map_err(|_| InfraError::OtherError("url err".to_string()))?;
        let conn_pool = SingleNodeConnectionPool::new(url_parsed);
        let transport = TransportBuilder::new(conn_pool)
            .disable_proxy()
            .build()
            .map_err(|_| InfraError::OtherError("transport err".to_string()))?;
        let client = Elasticsearch::new(transport);
        Ok(Arc::new(client))
    }
}

#[cfg(test)]
mod tests {
    use elasticsearch::{ cat::CatIndicesParts, DeleteParts, IndexParts, UpdateParts };
    use serde_json::json;
    use super::*;
    use crate::constant::CONFIG;
    #[tokio::test]
    async fn test_add_document() {
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        let response = client
            .index(IndexParts::IndexId("mgr", "1"))
            .body(
                json!({
                "id": 1,
                "user": "cci",
                "post_date": "2024-01-15T00:00:00Z",
                "message": "Trying out Elasticsearch, so far so good?"
            })
            )
            .send().await;
        assert!(response.is_ok());
        let response = response.unwrap();
        assert!(response.status_code().is_success());
    }
    #[tokio::test]
    async fn test_get_indices() {
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        let get_index_response = client
            .cat()
            .indices(CatIndicesParts::Index(&["*"]))
            .send().await;
        assert!(get_index_response.is_ok());
    }
    #[tokio::test]
    async fn test_update_document() {
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        let update_response = client
            .update(UpdateParts::IndexId("mgr", "1"))
            .body(
                json!({
                "doc": {
                    "message": "Updated message"
                }
            })
            )
            .send().await;
        assert!(update_response.is_ok());
        let update_response = update_response.unwrap();
        assert!(update_response.status_code().is_success());
    }
    #[tokio::test]
    async fn test_delete_document() {
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        let delete_response = client.delete(DeleteParts::IndexId("mgr", "1")).send().await;
        assert!(delete_response.is_ok());
        let delete_response = delete_response.unwrap();
        assert!(delete_response.status_code().is_success());
    }
}

        // 1、創(chuàng)建client
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        // 2、定義DSL語(yǔ)句
        let mut body: Vec<JsonBody<_>> = Vec::with_capacity(4);
        // 添加文檔
        body.push(json!({"index": {"_id": "1"}}).into());
        body.push(
            json!({
    "id": 1,
    "user": "kimchy",
    "post_date": "2009-11-15T00:00:00Z",
    "message": "Trying out Elasticsearch, so far so good?"
}).into()
        );
        // 添加文檔
        body.push(json!({"index": {"_id": "2"}}).into());
        body.push(
            json!({
    "id": 2,
    "user": "forloop",
    "post_date": "2020-01-08T00:00:00Z",
    "message": "Bulk indexing with the rust client, yeah!"
}).into()
        );
        // 3、發(fā)送請(qǐng)求
        let response = client.bulk(BulkParts::Index("mgr")).body(body).send().await.unwrap();

    #[tokio::test]
    async fn test_create_index() {
        // 1、創(chuàng)建client
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        // 2、定義DSL語(yǔ)句
        let index_name = "mgr";
        let index_definition =
            json!({
            "mappings":{
                "properties":{
                    "age":{
                        "type":"integer"
                    }
                }
            }
        });
        let body = Some(serde_json::to_vec(&index_definition).unwrap());
        let path = format!("/{}", index_name);
        let headers = HeaderMap::new();
        let query_string = None;
        let timeout = None;
        let method = Method::Put;
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            method,
            &path,
            headers,
            query_string,
            body,
            timeout
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_create_index() {
        // 1、創(chuàng)建client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、定義DSL
        let index_definition =
            json!({
            "mappings":{
                "properties":{
                    "age":{
                        "type":"integer"
                    }
                }
            }
        });
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Put,
            format!("/mgr").as_str(),
            HeaderMap::new(),
            None,
            Some(index_definition.to_string().as_bytes().to_vec()),
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_query_index() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、定義查詢 DSL 語(yǔ)句
        let query = json!({
        "query": {
            "match_all": {}
        }
    });
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Get,
            format!("/mgr/_search").as_str(),
            HeaderMap::new(),
            None,
            Some(query.to_string().as_bytes().to_vec()),
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_query_index2() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Get,
            format!("/mgr").as_str(),
            HeaderMap::new(),
            None,
            None,
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_update_index() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、定義查詢 DSL 語(yǔ)句
        let update_content = json!({
            "properties":{
                "age":{
                "type":"integer"
                }
            }
    });
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Put,
            format!("/mgr/_mapping").as_str(),
            HeaderMap::new(),
            None,
            Some(update_content.to_string().as_bytes().to_vec()),
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_delete_index() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、發(fā)送請(qǐng)求
        let response = client.send::<(), ()>(
            Method::Delete,
            format!("/mgr").as_str(),
            HeaderMap::new(),
            None,
            None,
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_create_doc() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、定義查詢 DSL 語(yǔ)句
        let doc_content =
            json!({
            "id": "1",
            "user": "kimchy",
            "post_date": "2009-11-15T00:00:00Z",
            "message": "Trying out Elasticsearch, so far so good?"
        });
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Post,
            format!("/mgr/_doc/1").as_str(),
            HeaderMap::new(),
            None,
            Some(doc_content.to_string().as_bytes().to_vec()),
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_get_doc() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Get,
            format!("/mgr/_doc/1").as_str(),
            HeaderMap::new(),
            None,
            None,
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_update_doc() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、定義查詢 DSL 語(yǔ)句
        let doc_content =
            json!({
            "doc": {
                "message": "Updated message"
            }
        });
        // 3、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Post,
            format!("/mgr/_update/1").as_str(),
            HeaderMap::new(),
            None,
            Some(doc_content.to_string().as_bytes().to_vec()),
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_delete_doc() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2、發(fā)送請(qǐng)求
        let response = client.send::<Vec<u8>, ()>(
            Method::Delete,
            format!("/mgr/_doc/1").as_str(),
            HeaderMap::new(),
            None,
            None,
            None
        ).await;
        assert!(response.is_ok());
        let response = response.unwrap();
        println!("{:?}", response);
        assert_eq!(response.status_code().is_success(), true);
    }

    #[tokio::test]
    async fn test_bulk_add_to_mgr() {
        // 1、創(chuàng)建client
        let client_result = EsClient::build_from_config(&CONFIG).await;
        assert!(client_result.is_ok());
        let client = client_result.unwrap();
        // 2、定義DSL語(yǔ)句
        let mut body: Vec<JsonBody<_>> = Vec::with_capacity(4);
        // 添加第一個(gè)操作和文檔
        body.push(json!({"index": {"_id": "1"}}).into());
        body.push(
            json!({
    "id": 1,
    "user": "kimchy",
    "post_date": "2009-11-15T00:00:00Z",
    "message": "Trying out Elasticsearch, so far so good?"
}).into()
        );
        // 添加第二個(gè)操作和文檔
        body.push(json!({"index": {"_id": "2"}}).into());
        body.push(
            json!({
    "id": 2,
    "user": "forloop",
    "post_date": "2020-01-08T00:00:00Z",
    "message": "Bulk indexing with the rust client, yeah!"
}).into()
        );
        // 3、發(fā)送請(qǐng)求
        let response = client.bulk(BulkParts::Index("mgr")).body(body).send().await.unwrap();
        assert!(response.status_code().is_success());
    }

    #[tokio::test]
    async fn test_search_match_all() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "match_all": {
                }
            }
        })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "match_all": {}
  }
}

    #[tokio::test]
    async fn test_search_match() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "match": {
                    "message": "good"
                }
            }
        })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "match": {
      "message": "good"
    }
  }
}

    #[tokio::test]
    async fn test_search_multi_match() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "multi_match": {
                    "query": "good",
                    "fields": [
                        "message",
                        "user"
                        ]
                    }
                }
            })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "multi_match": {
      "query": "good",
      "fields": [
        "message",
        "user"
      ]
    }
  }
}

    #[tokio::test]
    async fn test_search_range() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "range": {
                    "id": {
                        "gte": 1,
                        "lte": 1
                        }
                    }
                }
            })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "range": {
      "id": {
        "gte": 1,
        "lte": 1
      }
    }
  }
}

    #[tokio::test]
    async fn test_search_term() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "term": {
                    "user": "kimchy"
                    }
                }
            })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "term": {
      "user": "kimchy"
    }
  }
}

GET /mgr/_search
{
  "query": {
    "geo_distance": {
      "distance": "100km",
      "location": "31.04, 45.12"
    }
  }
}

GET /mgr/_search
{
  "query": {
    "geo_bounding_box": {
      "geo": {
        "top_left": {
          "lon": 124.45,
          "lat": 32.11
        },
        "bottom_right": {
          "lon": 125.12,
          "lat": 30.21
        }
      }
    }
  }
}

GET /mgr/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {// 查詢方法
        "message": "good"
        }
      },
      "functions": [ // 算分函數(shù)
        {
          "filter": {// 只有符合過(guò)濾條件的才被計(jì)算
          "term": {// 根據(jù)詞條精確查詢
          "id": 1
          }
          },
          "weight": 3 // 指定加權(quán)函數(shù)
        }
        ],
        // 加權(quán)模式：相乘
        "boost_mode": "multiply"
    }
  }
}

    #[tokio::test]
    async fn test_function_score_query() {
        // 1、創(chuàng)建 client
        let client = EsClient::build_from_config(&CONFIG).await.unwrap();
        // 2. 執(zhí)行搜索
        let response = client
            .search(SearchParts::Index(&["mgr"]))
            .from(0)
            .size(5)
            .body(
                json!({
            "query": {
                "function_score": {
                    "query": {
                        "match": {// 查詢方法
                        "message": "good"
                        }
                    },
                    "functions": [ // 算分函數(shù)
                    {
                        "filter": {// 只有符合過(guò)濾條件的才被計(jì)算
                        "term": {// 根據(jù)詞條精確查詢
                        "id": 1
                        }
                        },
                        "weight": 3 // 指定加權(quán)函數(shù)
                    }
                ],
                    // 加權(quán)模式：相乘
                    "boost_mode": "multiply"
                    }
                }
            })
            )
            .send().await
            .unwrap();
        // 3. 解析響應(yīng)
        let response_body = response.json::<Value>().await.unwrap();
        // 搜索耗時(shí)
        let took = response_body["took"].as_i64().unwrap();
        println!("took: {}ms", took);
        // 搜索結(jié)果
        for hit in response_body["hits"]["hits"].as_array().unwrap() {
            println!("{:?}", hit["_source"]);
        }
    }

GET /mgr/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match_phrase": {
            "message": "rust"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "post_date": {
              "lt": "2020-01-01T00:00:00Z"
            }
          }
        }
      ]
    }
  }
}

GET /mgr/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "id": "desc"http:// ASC升序，DESC降序
    }
  ]
}

GET /mgr/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance":{
        "FIELD": {
          "lat": 40,// 緯度
          "lon": -70// 經(jīng)度
        },
        "order":"asc",// 排序方式
        "unit":"km" // 單位
      }
    }
  ]
}

GET /mgr/_search
{
  "query": {
    "match_all": {}
  },
  "from":1,// 分頁(yè)開(kāi)始位置
  "size":10,// 期望獲取的文檔總數(shù)
  "sort": [
    {
      "id": "desc"http:// ASC升序，DESC降序
    }
    ]
}

GET /mgr/_search
{
  "query": {
    "match": {
      "message":"rust"http:// 搜索message中包含rust的文檔
    }
  },
  "highlight":{
    "fields":{
      "message":{// 指定高亮字段
      "require_field_match":"false"http:// 搜索字段和高亮字段可以不匹配
      }
    }
  }
}

GET /mgr/_search
{
  "size":0,// 文檔大小，結(jié)果不包含文檔，只包含聚合結(jié)果
  "aggs": {//指定聚合
    "idAgg": {// 聚合名
      "terms": {// 精確查詢
        "field":"id",// 指定字段
        "order":{
          "_count":"asc"http:// 按升序排序
        }
      }
    }
  }
}

GET /mgr/_search
{
  "size":0,// 文檔大小，結(jié)果不包含文檔，只包含聚合結(jié)果
  "aggs": {//指定聚合
    "idAgg": {// 聚合名
      "terms": {// 精確查詢
        "field":"id",// 指定字段
        "size":20
      },
      "aggs":{// 子聚合
        "score_stats":{// 聚合名
          "max":{//聚合類型，min、max、avg等
            "field":"score"http:// 聚合字段
          }
        }
      }
    }
  }
}

PUT /test
{
  "settings": {// 設(shè)置
    "analysis": {
      "analyzer": {// 設(shè)置分詞器
        "my_analyzer": {// 分詞器名
          "filters": [
           "lowercase",// 轉(zhuǎn)小寫
           "stop"http:// 去停用詞
         ],
          "tokenizer": "ik_max_word", // 分詞器
          "filter": "py" // 過(guò)濾時(shí)進(jìn)行拼音
        }
      }
    },
    "filter": { // 自定義tokenizer filter
      "py": { // 過(guò)濾器名稱
        "type": "pinyin", // 過(guò)濾器類型，這里是pinyin
        "keep_full_pinyin": false,// 是否保留完整的拼音形式
        "keep_joined_full_pinyin": true,// 是否保留連接起來(lái)的完整拼音形式
        "keep_original": true,// 是否保留原始的文本內(nèi)容
        "limit_first_letter_length": 16,// 限制拼音首字母的長(zhǎng)度為 16
        "remove_duplicated_term": true,// 是否移除重復(fù)的詞條
        "none_chinese_pinyin_tokenize": false// 不對(duì)非中文字符進(jìn)行拼音分詞
      }
    }
  },
  "mappings": {
    "properties": {
      "user": {
        "type": "completion"
      }
    }
  }
}

PUT /test
{
  "mappings": {
    "properties": {
      "user": {
        "type": "completion"
      }
    }
  }
}

POST /test/_doc/1
{
  "id": 1,
  "message": "Trying out Elasticsearch, so far so good?",
  "post_date": "2009-11-15T00:00:00Z",
  "user": "kimchy"
}

GET /test/_search
{
  "suggest": {
    "YOUR_SUGGESTION": {// 指定自動(dòng)補(bǔ)全查詢名字
    "text": "k",// 關(guān)鍵字前綴
    "completion": {// 自動(dòng)補(bǔ)全類型
      "field": "user",// 補(bǔ)全字段
      "skip_duplicates": true,// 是否跳過(guò)重復(fù)的建議
      "size": 10 // 獲取前10條結(jié)果
    }
    }
  }
}