elasticsearch

文档地址

elasticsearch2

elasticsearch高级检索

网址

官网 https://www.elastic.co/

java client
https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/indexing.html

Java REST Client (deprecated)
https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html

Java Transport Client (deprecated)
https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-search-template.html

参考文档地址
https://www.elastic.co/guide/en/elasticsearch/reference/index.html
https://www.elastic.co/guide/en/elasticsearch/reference/7.10/index.html

jdk兼容性
https://www.elastic.co/cn/support/matrix#matrix_jvm

操作系统兼容性
https://www.elastic.co/cn/support/matrix

ELK的自身兼容性
https://www.elastic.co/cn/support/matrix#matrix_compatibility

es下载地址
https://www.elastic.co/cn/downloads/elasticsearch
https://www.elastic.co/cn/downloads/past-releases#elasticsearch

es字段数据类型
https://www.elastic.co/guide/en/elasticsearch/reference/7.6/mapping-types.html

数据库使用排行查看
https://db-engines.com/en/ranking

搜索引擎排行查看
https://db-engines.com/en/ranking/search+engine

kibana下载地址
https://www.elastic.co/cn/downloads/kibana

参考文档

https://blog.csdn.net/u011863024/article/details/115721328#31Linux_3821

查询参数

track_total_hits                                       可以查询大于1万的数据

单机部署

1、下载：https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-8-0

2、创建es启动用户
useradd es                                 新增 es 用户
passwd es                                  为 es 用户设置密码
userdel -r es                              如果错了，可以删除再加
chown -R es:es /data/rbc/es                文件夹所有者

3、修改配置文件/config/elasticsearch.yml，加入如下配置
cluster.name: elasticsearch                 集群名称
node.name: node-1                           几点名称
network.host: linu01                        服务器ip
http.port: 9200                             访问端口
cluster.initial_master_nodes: ["node-1"]    主节点名称
path.data: ./data
path.logs: ./logs

4、修改/etc/security/limits.conf
# 在文件末尾中增加下面内容，每个进程可以打开的文件数的限制
es soft nofile 65536                        es表示es用户
es hard nofile 65536

5、修改/etc/security/limits.d/20-nproc.conf
# 在文件末尾中增加下面内容，每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536
* hard nproc 4096                             操作系统级别对每个用户创建的进程数的限制, * 代表Linux所有用户名称

6、修改/etc/sysctl.conf
vm.max_map_count=655360                       增加此内容，一个进程可以拥有的VMA(虚拟内存区域)的数量,默认值为 65536
sysctl -p                                     重新加载

7、修改jvm.options配置
-Xms4g
-Xmx4g

8、启动
bin/elasticsearch                            控制台启动
bin/elasticsearch -d                         后台启动

9、停止es
pkill -F pid

10、访问
http://IP:9200/

集群部署

1、下载：https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-8-0

2、创建es启动用户
useradd es                                         新增 es 用户
passwd es                                          为 es 用户设置密码
userdel -r es                                      如果错了，可以删除再加
chown -R es:es /data/rbc/es                        文件夹所有者

3、修改配置文件/config/elasticsearch.yml，加入如下配置
cluster.name: cluster-es                           自定义集群名称，所有的ES必须是同一个名称，否则会视为不同集群
node.name: node-1                                  节点名称，每个节点的名称不能重复
network.host: linu01                               节点所绑定的IP地址，每个节点的地址不能重复
node.master: true                                  是不是有资格主节点
node.data: true                                    是不是数据节点
http.port: 9200                                    对外访问
transport.tcp.port: 9300                           es各节点之间通信

cluster.initial_master_nodes: ["node-1"]                           #es7.x之后新增的配置，初始化一个新的集群时需要此配置来选举 master
discovery.seed_hosts: ["linux1:9300","linux2:9300","linux3:9300"]  #es7.x之后新增的配置，配置集群的主机地址

path.data: ./data
path.logs: ./logs

gateway.recover_after_nodes: 2
network.tcp.keep_alive: true
network.tcp.no_delay: true
transport.tcp.compress: true

cluster.routing.allocation.cluster_concurrent_rebalance: 16         集群内同时启动的数据任务个数，默认是2个
cluster.routing.allocation.node_concurrent_recoveries: 16           添加或删除节点及负载均衡时并发恢复的线程个数，默认4个
cluster.routing.allocation.node_initial_primaries_recoveries: 16    初始化数据恢复时，并发恢复线程的个数，默认4个

head 插件需要这打开这两个配置，跨域时使用
http.cors.allow-origin: "*"
http.cors.enabled: true

4、修改配置文件/etc/security/limits.conf
# 在文件末尾中增加下面内容，每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536

5、修改配置文件/etc/security/limits.d/20-nproc.conf
# 在文件末尾中增加下面内容，每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536
* hard nproc 4096                             操作系统级别对每个用户创建的进程数的限制, * 代表Linux所有用户名称

6、修改配置文件/etc/sysctl.conf
vm.max_map_count=655360                       增加此内容，一个进程可以拥有的VMA(虚拟内存区域)的数量,默认值为 65536
sysctl -p                                     重新加载

7、修改jvm.options配置
-Xms4g
-Xmx4g

8、分别在不同节点上启动
bin/elasticsearch                            控制台启动
bin/elasticsearch -d  -p pid                 后台启动
    将进程ID记录到pid文件

9、停止es
pkill -F pid

10、测试集群
http://IP:9200/_cat/nodes

设置es密码，使用的Xpack

# 参考文档
https://www.cnblogs.com/djd66/p/16828001.html
https://www.cnblogs.com/zhangmingcheng/p/14572877.html
https://www.cnblogs.com/cjzzz/p/16133347.html
https://www.cnblogs.com/h--d/p/13128635.html

# 什么是Xpack
X-Pack是Elastic Stack扩展功能，提供安全性，警报，监视，报告，机器学习和许多其他功能。 ES7.0+之后，默认情况下，当安装Elasticsearch时，会安装X-Pack，无需单独再安装。
自6.8以及7.1+版本之后，基础级安全永久免费。

1、创建一个证书颁发机构
bin/elasticsearch-certutil ca

2、在节点生成证书和私钥
./bin/elasticsearch-certutil cert --ca elastic-stack-ca.p12

3、把生成的文件elastic-certificates.p12放到config下，并发送到其它集群节点

4、修改配置并启动
xpack.security.enabled: true                   开机xpack安全认证，默认为false
xpack.security.transport.ssl.enabled: true     必须开启，节点间ssl通信
# 验证模式：证书，指定证书位置
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: elastic-certificates.p12

5、ES需是启动状态，在集群的其中一个节点设置密码即可，设置完之后，数据会自动同步到其他节点(后面加入的ES节点，也会自动同步)。
bin/elasticsearch-setup-passwords interactive
  --elastic 超级用户账号：拥有 superuser 角色，是内置的超级用户。
  --kibana 账号：拥有 kibana_system 角色，用户 kibana 用来连接 elasticsearch 并与之通信。
  --logstash_system 账号：拥有 logstash_system 角色。用户 Logstash 在 Elasticsearch 中存储监控信息时使用。
  --beats_system账号：拥有 beats_system 角色。用户 Beats 在 Elasticsearch 中存储监控信息时使用。

6、重置密码时，在高版本有重置密码命令，在低版本的只能删除数据文件及文件elasticsearch.keystore

ELK操作

配置es-head跨域可访问
http.cors.enabled: true
http.cors.allow-origin: "*"

让外网可访问主要修改文件 config/elasticsearch.yml，添加配置
network.host: 0.0.0.0
bootstrap.system_call_filter: false
cluster.initial_master_nodes: ["node-1"]

es启动
bin/elasticsearch -d
或 bin/elasticsearch -d -p pid
或 bin/elasticsearch &

es停止
cat pid|xargs kill

es访问
http://localhost:9200

kibana启动、停止
bin/kibana
kill -9 pid

kibana访问
http://localhost:5601

Kibana启动报错 kibana server is not ready yet
1.kibana与es版本不兼容
2.kibana中配置的es地址elasticsearch.hosts不对
3.es禁止跨域访问
4.服务器开启了防火墙
5.es磁盘空间已使用90%

通过get _cat/ 可以获取ElasticSearch的当前的很多信息！

GET _cat/indices
GET _cat/aliases
GET _cat/allocation
GET _cat/count
GET _cat/fielddata
GET _cat/health
GET _cat/indices
GET _cat/master
GET _cat/nodeattrs
GET _cat/nodes
GET _cat/pending_tasks
GET _cat/plugins
GET _cat/recovery
GET _cat/repositories
GET _cat/segments
GET _cat/shards
GET _cat/snapshots
GET _cat/tasks
GET _cat/templates
GET _cat/thread_pool

查询多个索引数据时

POST indexName1,indexName2/_search

匹配所有字段规则

匹配字段不加时默认是全部，或者加上*也是表示全部 fields":["*"],

索引的CRUD

# 搜索功能
当给索引字段指定分词器时，字段数据会根据指定的分词器创建倒排索引，在搜索时，如果搜索字段未指定分词器，默认使用索引字段指定的分词器

分词器
GET _analyze
{
  "analyzer": "standard",
  "text": "中华人民共和国"
}

分词器
GET _analyze
{
  "analyzer":"ik_max_word",
  "text":"中华人民共和国"
}


查询索引
GET test_index
GET test_index/_mapping
GET _cat/indices?v

查看指定字段mapping
GET test_index/_mappings

删除索引
DELETE test_index

添加空mapping索引
PUT test_index

添加指定mapping索引
PUT test_index
{
  "mappings": {
    "properties": {
        "name" : {
          "type" : "text",
          "analyzer": "ik_max_word",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
  }
}

根据id查询
GET test_index/_doc/1

查询所用
GET test_index/_search

带参数查询
GET test_index/_search?q=name:小红

分页并排序
GET test_index/_search?from=0&size=2&sort=age:asc

post方法直接搜索
POST test_index/_search

post方法多字段查询
POST test_index/_search
{
 "query": {
   "multi_match": {
     "query": "订单",
     "fields": ["name1", "name2"]
   }
 }
}

post方法复杂搜索
POST test_index/_search
{
  "_source": ["name", "age"],
  "query": {
    "match": {
      "name": {
         "query": "小红",
         "analyzer": "ik_max_word"   #指定查询字段分词器，默认使用索引设置的
      }
    }
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 10
}

添加数据自动生成id
POST test_index/_doc
{
  "name":"小红同学",
  "age":22
}

添加数据指定id
POST test_index/_doc/1
{
  "name":"小红同学",
  "age":22
}

删除数据
DELETE test_index/_doc/1

更新数据(会丢失数据)
PUT test_index/_doc/1
{
  "name" : "小红2"
}

更新数据（不会丢失）
POST test_index/_update/1
{
  "doc": {
    "name" : "小红2"
  }
}

推荐搜索相关

# 创建推荐搜索的索引方式1
PUT product_suggest
{
  "mappings" : {
    "properties" : {
      "fileName" : {
        "type" : "completion",
        "analyzer":"ik_max_word"
      }
    }
  }
}

# 创建推荐搜索的索引方式2
PUT product_suggest
{
  "mappings" : {
    "properties" : {
      "fileName" : {
          "type": "text",
          "analyzer": "ik_max_word",
          "fields": {
          "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            },
            "suggest": {
              "type": "completion",
              "analyzer": "ik_max_word"
            }
          }
        }
    }
  }
}

# 推荐搜索
POST product_suggest/_search
{
    "suggest":{
        "my_suggest":{
            "prefix":"中国",
            "completion":{
                "field":"fieldName.suggest",
                "size":10,
                "skip_duplicates":true
            }
        }
    }
}

搜索和查询 Query DSL（Domain Specific Language）特定领域语言

示例代码

DELETE product
PUT /product/_doc/1
{
    "name" : "xiaomi phone",
    "desc" :  "shouji zhong de zhandouji",
    "date": "2021-06-01",
    "price" :  3999,
    "tags": [ "xingjiabi", "fashao", "buka" ]
}
PUT /product/_doc/2
{
    "name" : "xiaomi nfc phone",
    "desc" :  "zhichi quangongneng nfc,shouji zhong de jianjiji",
    "date": "2021-06-02",
    "price" :  4999,
    "tags": [ "xingjiabi", "fashao", "gongjiaoka" ]
}
PUT /product/_doc/3
{
    "name" : "nfc phone",
    "desc" :  "shouji zhong de hongzhaji",
    "date": "2021-06-03",
    "price" :  2999,
    "tags": [ "xingjiabi", "fashao", "menjinka" ]
}
PUT /product/_doc/4
{
    "name" : "xiaomi erji",
    "desc" :  "erji zhong de huangmenji",
    "date": "2021-04-15",
    "price" :  999,
    "tags": [ "low", "bufangshui", "yinzhicha" ]
}
PUT /product/_doc/5
{
    "name" : "hongmi erji",
    "desc" :  "erji zhong de kendeji 2021-06-01",
    "date": "2021-04-16",
    "price" :  399,
    "tags": [ "lowbee", "xuhangduan", "zhiliangx" ]
}
GET product/_search
GET product/_search
{
  "_source": false, 
  "query": {
    "match_all": {}
  }
}
PUT /product2/_doc/1
{
  "owner":{
    "name":"zhangsan",
    "sex":"男",
    "age":18
  },
  "name": "hongmi erji",
  "desc": "erji zhong de kendeji",
  "price": 399,
  "tags": [
    "lowbee",
    "xuhangduan",
    "zhiliangx"
  ]
}
PUT product2
{
  "mappings": {
    "_source": {
      "includes": [
        "name",
        "price"
      ],
      "excludes": [
        "desc",
        "tags"
      ]
    }
  }
}
DELETE product2
GET product2/_search
{
  "_source": ["owner.name","owner.sex"], 
  "query": {
    "match_all": {}
  }
}
GET product2/_search
GET product2/_search
{
  "_source": {
    "includes": [
      "owner.*",
      "name"
    ],
    "excludes": [
      "name", 
      "desc",
      "price"
    ]
  },
  "query": {
    "match_all": {}
  }
}
GET _search

# DSL

# match

GET product/_search
{
  "query": {
    "match": {
      "name": "xiaomi nfc phone"
    }
  }
}

# match_all

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

# select field1,field2 from table where a=xx and b=xx

# multi_match

GET product/_search
{
  "query": {
    "multi_match": {
      "query": "phone huangmenji",
      "fields": ["name","desc"]
    }
  }
}

# match_phrase

GET product/_mapping
GET product/_search
{
  "query": {
    "match_phrase": {
      "name": "xiaomi nfc"
    }
  }
}

GET _analyze
{
  "analyzer": "standard",
  "text": "xiaomi nfc phone"
}

# Term

GET product/_search
{
  "query": {
    "match": {
      "name": "xiaomi phone"
    }
  }
}
GET product/_search
{
  "query": {
    "term": {
      "name": "xiaomi phone"
    }
  }
}
GET product/_search
{
  "query": {
    "term": {
      "name": "xiaomi phone"
    }
  }
}
#term和match_phrase区别
GET product/_search
{
  "query": {
    "match_phrase": {
      "name": "xiaomi phone"
    }
  }
}
#term和keyword的区别
GET product/_mapping
GET product/_search
{
  "query": {
    "term": {
      "name": "xiaomi phone"
    }
  }
}
GET product/_search
{
  "query": {
    "term": {
      "name.keyword": "xiaomi phone"
    }
  }
}

# terms

GET product/_search
{
  "query": {
    "terms": {
      "tags": [ "lowbee", "gongjiaoka" ],
      "boost": 1.0
    }
  }
}

# range

GET /_search
{
  "query": {
    "range": {
      "age": {
        "gte": 10,
        "lte": 20,
        "boost": 2.0
      }
    }
  }
}
GET product/_search
GET product/_search
{
  "query": {
    "range": {
      "date": {
        "gte": "2021-04-15",
        "lt": "2021-04-16"
      }
    }
  }
}
GET product/_search
{
  "query": {
    "range": {
      "date": {
        "gte": "now-1d/d",
        "lt": "now/d"
      }
    }
  }
}
GET product/_search
{
  "query": {
    "range": {
      "date": {
        "time_zone": "+08:00",      
        "gte": "2021-04-15T08:00:00", 
        "lt": "now"                
      }
    }
  }
}

# filter

GET product/_search
GET product/_search
{
  "query": {
    "match": {
      "name": "phone"
    }
  }
}
GET product/_search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": {
          "name": "phone"
        }
      },
      "boost": 1.2
    }
  }
}
GET product/_search
{
  "query": {
    "bool": {
      "filter": {
        "term": {
          "name": "phone"
        }
      }
    }
  }
}

# bool query 组合查询

#must 计算相关度得分
#条件1:包含"xiaomi"或"phone"
#条件2:包含"shouji zhong"

#filter 不计算相关度得分
GET product/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "match": {
            "name": "xiaomi phone"
          }
        },
        {
          "match_phrase": {
            "desc": "shouji zhong"
          }
        }
      ]
    }
  }
}
#must not 不计算相关度得分
#条件1: 排除包含xiaomi的和包含nfc的(不能包含xiaomi和nfc中的任意一个)
#条件2: 排除价格大于等于500的
GET product/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "gte": "500"
            }
          }
        }
      ]
    }
  }
}
#should
GET product/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "lte": "500"
            }
          }
        }
      ]
    }
  }
}
#组合查询
GET product/_search
{
  "_source": false,
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}
#filter和must组合
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ],
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        },
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}
#(must或者filter)和should组合
#条件1:价格小于10000
#条件2:name中包含"hongmi"或者"xiaomi nfc phone"
GET product/_search
{
  "_source": false,
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "10000"
            }
          }
        }
      ],
      "should": [
        {
          "match_phrase": {
            "name": "nfc phone"
          }
        },
        {
          "match": {
            "name": "erji"
          }
        },
        {
          "bool": {
            "must": [
              {
                "range": {
                  "price": {
                    "gte": 900,
                    "lte": 3000
                  }
                }
              }
            ]
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

#filter 不计算相关度得分
GET product/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "match": {
            "name": "xiaomi phone"
          }
        },
        {
          "match_phrase": {
            "desc": "shouji zhong"
          }
        }
      ]
    }
  }
}
#must not 不计算相关度得分
#条件1: 排除包含xiaomi的和包含nfc的(不能包含xiaomi和nfc中的任意一个)
#条件2: 排除价格大于等于500的
GET product/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "gte": "500"
            }
          }
        }
      ]
    }
  }
}
#should
GET product/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "lte": "500"
            }
          }
        }
      ]
    }
  }
}
#组合查询
GET product/_search
{
  "_source": false,
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}
#filter和must组合
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ],
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}
GET product/_search
{
  "_source": false, 
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        },
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}
#(must或者filter)和should组合
#条件1:价格小于10000
#条件2:name中包含"hongmi"或者"xiaomi nfc phone"
GET product/_search
{
  "_source": false,
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "lte": "10000"
            }
          }
        }
      ],
      "should": [
        {
          "match_phrase": {
            "name": "nfc phone"
          }
        },
        {
          "match": {
            "name": "erji"
          }
        },
        {
          "bool": {
            "must": [
              {
                "range": {
                  "price": {
                    "gte": 900,
                    "lte": 3000
                  }
                }
              }
            ]
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

#元数据source的过滤
1."_source": "false",
2."_source": "obj.*",
3."_source": [ "obj1.*", "obj2.*" ],
4."_source": {"includes": [ "obj1.*", "obj2.*" ], "excludes": [ "*.description" ]}

#全文检索-Fulltext query
#keyword类型是全词匹配
#text类型适合match匹配

GET _analyze
{
  "analyzer": "standard",
  "text": "xiaomi nfc phone"
}

POST test_index/_search
{
  "query": {
     查询所用数据等价于直接查询 GET test_index/_search
    "match_all": {}
  }
}

POST test_index/_search
{
  "query": {
    name分词后搜索匹配
    "match": {
      "name": "小红 小明"
    }
  }
}

POST test_index/_search
{
  "query": {
    多字段查询匹配相同内容
    "multi_match": {
      "query": "phone huangmenji",
      "fields": ["name","desc"]
    }
  }
}

POST test_index/_search
{
  "query": {
     短语搜索，查询内容"xiaomi nfc"不会被分词查询
    "match_phrase": {
      "name": "xiaomi nfc"
    }
  }
}

#term和match_phrase区别:
1.match_phrase 会将检索关键词分词, match_phrase的分词结果必须在被检索字段的分词中都包含，而且顺序必须相同，而且默认必须都是连续的；
2.term搜索不会将搜索词分词，直接匹配搜索字段的分词，只要有一个分词匹配即命中；

#term和keyword区别
1.term是对于搜索词不分词；
2.keyword是字段数据类型,是对于source data中的字段值不分词；

#精准匹配 exact value
#term
POST test_index/_search
{
  "query": {
     term搜索不会将搜索词分词，直接匹配搜索字段的分词，只要有一个分词匹配即命中；
    "term": {
      "name": "xiaomi phone"
    }
  }
}

#terms
POST test_index/_search
{
  "query": {
    当字段类型为数组时，可以使用terms查询，数据数组中存在查询数组中任意一个即命中
    "terms": {
      "tags": [ "lowbee", "gongjiaoka" ],
      "boost": 1.0
    }
  }
}

# range 范围查询
#gte 大于等于
#lte 小于等于
#gt 大于
#lt 小于
POST test_index/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 10,
        "lte": 20,
        "boost": 2.0
      }
    }
  }
}

POST test_index/_search
{
  "query": {
    "range": {
      "date": {
        "gte": "2021-04-15",
        "lt": "2021-04-16"
      }
    }
  }
}

POST test_index/_search
{
  "query": {
    "range": {
      "date": {
        "time_zone": "+08:00", #添加时区
        "gte": "2021-04-15T08:00:00",
        "lt": "now"
      }
    }
  }
}

#过滤器-Filter不计算相关度得分
POST test_index/_search
{
  "query": {
    "match": {
      "name": "phone"
    }
  }
}

#query和filter的主要区别在
1.query倾向于“当前文档和查询的语句的相关度”,而filter倾向于“当前文档和查询的条件是不是相符”;
2.在查询过程中，query是要对查询的每个结果计算相关性得分的，而filter不会;
3.filter有相应的缓存机制，可以提高查询效率;

#filter
POST test_index/_search
{
  "query": {
    表示不以评分查询，查询出的数据评分是一样的
    "constant_score": {
      筛选数据条件，具体用处时在这里筛选数据后再用query查询
      "filter": {
        "term": {
          "name": "phone"
        }
      },
      "boost": 1.2
    }
  }
}

POST test_index/_search
{
  "query": {
    "bool": {
      "filter": {
        "term": {
          "name": "phone"
        }
      }
    }
  }
}

#组合查询 Bool query
must：必须满足子句出现在匹配的文档中，并将有助于得分。
filter：过滤器 不计算相关度分数，cache☆子句（查询）必须出现在匹配的文档中。但是不像 must查询的分数将被忽略。Filter子句在filter上下文中执行，这意味着计分被忽略，并且子句被考虑用于缓存。
should：可能满足or子句（查询）应出现在匹配的文档中。
must_not：必须不满足 不计算相关度分数 not子句（查询）不得出现在匹配的文档中。子句在过滤器上下文中执行，这意味着计分被忽略，并且子句被视为用于缓存。由于忽略计分，0因此将返回所有文档的分数。

# bool query 组合查询

#must 计算相关度得分
#条件1:包含"xiaomi"或"phone"
#条件2:包含"shouji zhong"
POST test_index/_search
{
    "query":{
        "bool":{
            "must":[
                {
                    "match":{
                        "name":"xiaomi phone"
                    }
                },
                {
                    "match_phrase":{
                        "desc":"shouji zhong"
                    }
                }
            ]
        }
    }
}

#filter 不计算相关度得分
POST test_index/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "match": {
            "name": "xiaomi phone"
          }
        },
        {
          "match_phrase": {
            "desc": "shouji zhong"
          }
        }
      ]
    }
  }
}

#must not 不计算相关度得分
#条件1: 排除包含xiaomi的和包含nfc的(不能包含xiaomi和nfc中的任意一个)
#条件2: 排除价格大于等于500的
POST test_index/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "gte": "500"
            }
          }
        }
      ]
    }
  }
}

#should
#1: 包含xiaomi的或者包含nfc的
#2: 或者价格大于等于500的
POST test_index/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "name": "xiaomi nfc"
          }
        },
        {
          "range": {
            "price": {
              "lte": "500"
            }
          }
        }
      ]
    }
  }
}

#组合查询
POST test_index/_search
{
  "_source": false,
  "query": {
    "bool": {
      "must": [
        {
          查询匹配xiaomi的
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}

POST test_index/_search
{
  "_source": false,
  "query": {
    "bool": {
      过滤price小于等于1000的
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}

#filter和must组合
POST test_index/_search
{
  "_source": false,
  "query": {
    "bool": {
      先过滤查询数据
      "filter": [
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ],
      再匹配查询数据
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        }
      ]
    }
  }
}

POST test_index/_search
{
  "_source": false,
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "xiaomi"
          }
        },
        {
          "range": {
            "price": {
              "lte": "1000"
            }
          }
        }
      ]
    }
  }
}

#(must或者filter)和should组合
#条件1:价格小于10000
#条件2:name中包含"hongmi"或者"xiaomi nfc phone"
POST test_index/_search
{
  "_source": false,
  "query": {
    "bool": {
      查询价格小于10000
      "filter": [
        {
          "range": {
            "price": {
              "lte": "10000"
            }
          }
        }
      ],
      should等同于or
      "should": [
        {
          "match_phrase": {
            "name": "nfc phone"
          }
        },
        {
          "match": {
            "name": "erji"
          }
        },
        {
          "bool": {
            "must": [
              {
                "range": {
                  "price": {
                    "gte": 900,
                    "lte": 3000
                  }
                }
              }
            ]
          }
        }
      ],
      #should内的多个条件需要匹配的数量
      #bool查询包含should子句，而没有must或filter子句时默认值为 1。否则默认值为0
      "minimum_should_match": 2
    }
  }
}

参考文章地址

文章1

文章2

文章3

文章4

文章5

文章6

文章7

es-head安装

//head插件依赖node.js
下载node地址：https://nodejs.org/en/download
node版本查看：node -v
//安装grunt
npm install -g grunt-cli
grunt -version

1.修改/etc/elasticsearch/elasticsearch.yml，增加下面跨域访问参数，这样head插件可以访问es，修改后，重启elasticsearch
http.cors.enabled: true
http.cors.allow-origin: "*"

2.下载并安装、启动
git clone git://github.com/mobz/elasticsearch-head.git
或 直接下载https://github.com/mobz/elasticsearch-head
cd elasticsearch-head
npm install -g grunt-cli
npm install
grunt server
npm run start

3.默认监听地址是localhost，修改监控地址 vi head/Gruntfile.js，
文件，添加hostname:'*'

4.修改head 的链接地址 vi head/_site/app.js
this.base_uri = this.config.base_uri || this.prefs.get("app-base_uri") || "http://127.0.0.1:9200";

5.访问
http://localhost:9100

java示例 es7.4

ES条件查询
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.from(0);
sourceBuilder.size(1);
sourceBuilder.timeout(TimeValue.timeValueMillis(5000));
sourceBuilder.query(QueryBuilders.termQuery("tagId", tagId));
MapSearchResult pageResult = this.search(new SearchRequest(new String[]{indexTags}, sourceBuilder)); 

主键查询
GetResponse r = client.get(new GetRequest(index, id), RequestOptions.DEFAULT);
System.out.println(r.getSourceAsString()); 

批量主键获取
try {
 MultiGetRequest multiGetRequest = new MultiGetRequest();
 multiGetRequest.add(index, "1");
 multiGetRequest.add(index, "2");
 MultiGetResponse multiResponse = client.mget(multiGetRequest, RequestOptions.DEFAULT);
 MultiGetItemResponse[] itemResponses = multiResponse.getResponses();
 for (MultiGetItemResponse itemResponse : itemResponses) {
  GetResponse response = itemResponse.getResponse();
  System.out.println(response.getId() +":"+response.getSource());
 }
} catch (IOException e) {
}