zoukankan html css js c++ java

企业级搜索elasticsearch应用02-elasticsearch搜索

一。使用命令搜索

1》uri搜索(参考https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html)

uri搜索表示将查询以及操作的动作置于uri参数中
为了方便搜索添加测试数据（/root/my.json）

{"index":{"_id":"1"}}
{"id":"1","country":"美国","provice":"加利福尼亚州","city":"旧金山","age":"30","name":"John","desc":"John is come from austrina  John,s Dad is Johh Super"}  
{"index":{"_id":"2"}}
{"id":"2","country":"美国","provice":"加利福尼亚州","city":"好莱坞","age":"40","name":"Mike","desc":"Mike is come from austrina  Mike,s Dad  is Mike Super"}  
{"index":{"_id":"3"}}
{"id":"3","country":"美国","provice":"加利福尼亚州","city":"圣地牙哥","age":"50","name":"Cherry","desc":"Cherry is come from austrina  Cherry,s Dad  is Cherry Super"}  
{"index":{"_id":"4"}}
{"id":"4","country":"美国","provice":"德克萨斯州","city":"休斯顿","age":"60","name":"Miya","desc":"Miya is come from austrina  Miya,s Dad  is Miya Super"}  
{"index":{"_id":"5"}}
{"id":"5","country":"美国","provice":"德克萨斯州","city":"大学城","age":"70","name":"fubos","desc":"fubos is come from austrina  fubos,s Dad  is fubos Super"}  
{"index":{"_id":"6"}}
{"id":"6","country":"美国","provice":"德克萨斯州","city":"麦亚伦","age":"20","name":"marry","desc":"marry is come from austrina  marry,s Dad  is marry Super"}  
{"index":{"_id":"7"}}
{"id":"7","country":"中国","provice":"湖南省","city":"长沙市","age":"18","name":"张三","desc":"张三来自长沙市 是公务员一名"}  
{"index":{"_id":"8"}}
{"id":"8","country":"中国","provice":"湖南省","city":"岳阳市","age":"15","name":"李四","desc":"李四来自岳阳市 是一名清洁工"}  
{"index":{"_id":"9"}}
{"id":"9","country":"中国","provice":"湖南省","city":"株洲市","age":"33","name":"李光四","desc":"李光四 老家岳阳市 来自株洲 是李四的侄子"}  
{"index":{"_id":"10"}}
{"id":"10","country":"中国","provice":"广东省","city":"深圳市","age":"67","name":"王五","desc":"王五来自深圳市  是来自深圳的一名海关缉私精英"}  
{"index":{"_id":"11"}}
{"id":"11","country":"中国","provice":"广东省","city":"广州市","age":"89","name":"王冠宇","desc":"王冠宇是王五的儿子"}

使用bulkapi 来批量导入

cd /root && curl -XPOST '192.168.58.147:9200/user/info/_bulk?pretty' --data-binary @my.json

可以使用 _search api来实现文档的搜索比如（q=查询的列:值）

[root@node1 ~]# curl -XGET 'http://192.168.58.147:9200/_search?q=name=marry&pretty'
{
  "took" : 42,
  "timed_out" : false,
  "_shards" : {
    "total" : 10,
    "successful" : 10,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.6127073,
    "hits" : [
      {
        "_index" : "user",
        "_type" : "info",
        "_id" : "6",
        "_score" : 1.6127073,
        "_source" : {
          "id" : "6",
          "country_s" : "美国",
          "provice_s" : "德克萨斯州",
          "city_s" : "麦亚伦",
          "age_i" : "20",
          "name_s" : "marry",
          "desc_s" : "marry is come from austrina  marry,s Dad  is marry Super"
        }
      }
    ]
  }
}

查询所有用户索引中年龄是50的
curl -XGET 'http://192.168.58.147:9200/user/_search?q=age:50&pretty'
查询所有用户索引库中用户信息类型用户资产类型年龄是30的多个索引或者多个类型使用,隔开
curl -XGET 'http://192.168.58.147:9200/student/info,money/_search?q=age:30&pretty'
查询所有索引库中(_all)类型是info的年龄是30的用户
curl -XGET 'http://192.168.58.147:9200/_all/info/_search?q=age:30&pretty'
使用from指定从第几条开始查 size返回的结果数默认from=0 size=10
curl -XGET 'http://192.168.58.147:9200/user/_search?q=age:30&from=0&size=2&pretty'

常用的查询参数如下：

Name	Description
`q`	表示查询字符串
`df`	在查询中，当没有定义字段的前缀的情况下的默认字段前缀
`analyzer`	当分析查询字符串时，分析器的名字
`default_operator`	被用到的默认操作，有`AND`和`OR`两种，默认是`OR`
`explain`	对于每一个命中(hit)，对怎样得到命中得分的计算给出一个解释
`_source`	将其设置为false，查询就会放弃检索`_source`字段。你也可以通过设置`_source_include`和`_source_exclude`检索部分文档
`fields`	命中的文档返回的字段
`sort`	排序执行。可以以`fieldName`、`fieldName:asc`或者`fieldName:desc`的格式设置。`fieldName`既可以是存在的字段，也可以是`_score`字段。可以有多个sort参数
`track_scores`	当排序的时候，将其设置为true，可以返回相关度得分
`timeout`	默认没有timeout
`from`	默认是0
`size`	默认是10
`search_type`	搜索操作执行的类型，有`dfs_query_then_fetch`, `dfs_query_and_fetch`, `query_then_fetch`, `query_and_fetch`, `count`, `scan`几种，默认是`query_then_fetch`
`lowercase_expanded_terms`	terms是否自动小写，默认是true
`analyze_wildcard`	是否分配通配符和前缀查询，默认是false
`terminate_after`	The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early. If set, the response will have a boolean field terminated_early to indicate whether the query execution has actually terminated_early. Defaults to no terminate_after.

指定使用中文名查询时都无法查询数据应该是分词器分词的问题

curl -XGET 'http://192.168.58.147:9200/user/info/_search?q=name=张&pretty'   
curl -XGET 'http://192.168.58.147:9200/user/info/_search?q=name=张三&pretty'

测试默认分词器的分词功能

[root@node1 ~]# curl -XPOST  'http://192.168.58.147:9200/_analyze?pretty' -d '
> {
>   "tokenizer": "standard",
>   "text":      "我是饺子"
> }';
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "饺",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "子",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "<IDEOGRAPHIC>",
      "position" : 3
    }
  ]
}

既然是逐个分词 q=name:张应该可以查出来啊奇怪后来想到http协议有可能在url上带参数中文乱码不使用url方式使用requestbody的方式试试

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
        "term" : { "name" : "三" }
    }
}'

发现这样搜索就是搜索张或者三都能出结果输入张三无法出结果确实是standard分词器的特点
实际上张三就是一个词这里推荐使用ik分词器的分词分成的词具有一定的意义（比如我是中国人拆分成我是中国人中国等有意义的词）

设置ik分词器（IK插件地址 https://github.com/medcl/elasticsearch-analysis-ik）

我这里5.6.4的es下载对应 5.6.4的ik

cd /home/es/elasticsearch-5.6.4 &&
    ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.6.4/elasticsearch-analysis-ik-5.6.4.zip

安装完成后检查plugins目录

[es@node1 elasticsearch-5.6.4]$ cd plugins/
[es@node1 plugins]$ ll
total 4
drwxr-xr-x 2 es es 4096 Dec  5 18:49 analysis-ik

重启 elasticsearch

 ./elasticsearch -Ecluster.name=my_cluster_name -Enode.name=my_node_name -Enetwork.host=192.168.58.147

ik 带有两个分词器
ik_max_word ：会将文本做最细粒度的拆分；尽可能多的拆分出词语
ik_smart：会做最粗粒度的拆分；已被分出的词语将不会再次被其它词语占有
测试

[es@node1 plugins]$ curl -XGET 'http://192.168.58.147:9200/_analyze?pretty&analyzer=ik_max_word' -d '我是中国人'
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "中国",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "国人",
      "start_offset" : 3,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 4
    }
  ]
}
[es@node1 plugins]$ curl -XGET 'http://192.168.58.147:9200/_analyze?pretty&analyzer=ik_smart' -d '我是中国人'        
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    }
  ]
}

删除索引user 重新创建索引 user

 curl -XDELETE 'http://192.168.58.147:9200/user?pretty'  
 curl -XPUT 'http://192.168.58.147:9200/user?pretty' -d '{
    "settings" : {
        "analysis" : {
            "analyzer" : {
                "ik" : {
                    "tokenizer" : "ik_max_word"
                }
            }
        }
    },
    "mappings" : {
        "info" : {
            "dynamic" : true,
            "properties" : {
                "name" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word"
                },"desc" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word"
                }
            }
        }
    }
}';

上面的创建表示设置 user的分词器是ik mapping用于设置类型和属性的类型以及他的分词器
info类型下的name_s和desc_s使用分词器
再次进入/root导入之前的数据文件

cd /root && curl -XPOST '192.168.58.147:9200/user/info/_bulk?pretty' --data-binary @my.json

测试分词器的效果发现张无法查询了张三才能查询

[root@node1 ~]# curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
        "term" : { "name" : "张" }  
    }
}'；
{
  "took" : 22,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 0,
    "max_score" : null,
    "hits" : [ ]
  }
}

2》请求体搜索

》》term 词查询
中文搜索只能使用请求体搜索否则无法搜索所以一般搜索都是使用请求体简单测试使用uri搜索一般请求体中使用dsl语言比如
查询所有数据

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {

    }
}';

查询包含词 name字段=三的

"query" : {
        "term" : { "name" : "三" }
    }

和query同级支持以下参数

Name	Description
`timeout`	默认没有timeout
`from`	默认是0
`size`	默认是10
`search_type`	搜索操作执行的类型，有`dfs_query_then_fetch`, `dfs_query_and_fetch`, `query_then_fetch`, `query_and_fetch`, `count`, `scan`几种，默认是`query_then_fetch`
`query_cache`	当`?search_type=count`时，查询结果是否缓存
`terminate_after`	The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early. If set, the response will have a boolean field terminated_early to indicate whether the query execution has actually terminated_early. Defaults to no terminate_after.

from和size 设置分页 order设置排序(注意请求体的参数不要用tab键代替空格否则出错)

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "from":0,
  "size":5,
  "sort":[
	{"_score":{"order":"desc"}},
	{"age":{"order":"desc"}}
  ],
  "query" : {
        "term" : { "desc" : "来自" }
    }
}';

按照每个document的得分降序得分相同的数据再按照age降序排序我之前导入数据时 age使用的""表示是字符串一般都会抛出异常

"reason": "Fielddata is disabled on text fields by default. Set fielddata=true on

表示默认的字符串不允许排序或者聚合应该将fielddata设置为true 修改之前创建的映射添加一个age将fielddata设置为true

"properties" : {
                "name" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word"
                },"desc" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word"
                },"age" : {
                    "type" : "string",
                     "fielddata" : true 
                }
            }

或者 type改成integer

"age" : {
                    "type" : "integer"
         }

_source指定显示哪些列

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
        "term" : { "desc" : "来自" }
    },
    "_source":["name", "desc"]
}';

》》terms 词查询

terms和term功能类似允许搜索多个词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
     "terms" : {
       "desc" : ["来自","com"]
     }
   }
}';

》》match查询

对比term和match区别

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
       "term" : { "desc" : "李 来自" }
    }
}';
curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
       "match" : { "desc" : "李 来自" }
    }
}';

term会认为李来自是一个词去匹配所有查不到任何数据
match 将包含李和来自两个词的数据合并查询
还有另外一个match_phrase和term是一样的认为是一个词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": { "match_phrase": { "desc" : "李 来自" } }
}'

》》bool查询
bool查询可以组合查询比如 must必须两个条件都满足必须有李和来自两个词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
    "bool": {
      "must": [
        { "match": { "desc": "李" } },
        { "match": { "desc": "来自" } }
      ]
    }
  }
}'

should 出现任意一个词即可

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
    "bool": {
      "should": [
        { "match": { "desc": "李" } },
        { "match": { "desc": "来自" } }
      ]
    }
  }
}';

must_not必须没有某些词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
    "bool": {
      "must_not": [
        { "match": { "desc": "李" } },
        { "match": { "desc": "来自" } }
      ]
    }
  }
}';

也可以组合使用必须出现词李不能出现词来自

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
    "bool": {
      "must_not": [
        { "match": { "desc": "李" } }
      ],
	  "must":[{ "match": { "desc": "来自" } }]
    }
  }
}';

》》regexp正则查询

支持正则匹配模式例如

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
       "regexp" : { "desc" : "李.*" }
    }
}';

》》prefix前缀查询
以什么词开头必须是一个词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
       "prefix" : { "desc" : "李" }
    }
}';

》》multi_match多字段查询

多个字段等于同一个词

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
     "multi_match" : {
       "query" : "李" ,
	   "fields":["name","desc"]
     }
   }
}';

》》range范围过滤

范围操作符包含：

gt :: 大于
gte:: 大于等于
lt :: 小于
lte:: 小于等于

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
     "range" : {
       "age" : {"gt":20}
     }
   }
}';

假设需要判断 age>=20 and age<=30
使用range

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query": {
     "range" : {
       "age" : {"gte":20,"lte":"30"}
     }
   }
}';

可是使用bool

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query":{
  "bool":{
   "must": {
     "range" : {
       "age" : {"gte":20}
      }
    },
   "must": {
     "range" : {
       "age" : {"lte":30}
      }
     }
   }
   }
}';

》》exists 和 missing 过滤

exists 和 missing 过滤可以用于查找文档中是否包含指定字段或没有某个字段

比如查询所有带有age字段的doc

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
    "query":{
	   "exists":{"field":"age"}
	}
}';

查询所有没有 age字段的doc
miising已经过期替代的是使用bool+exists

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query":{
  "bool":{
   "must_not": {
     "exists" : {
       "field":"age"
      }
    }
   }
   }
}';

3》过滤

每次的搜索返回的结果中都有一个_score的字段这个得分是指定的搜索查询匹配程度的一个相对度量。得分越高，文档越相关，
得分越低文档的相关度越低。

Elasticsearch中的所有的查询都会触发相关度得分的计算。对于那些我们不需要相关度得分的场景下，Elasticsearch以过滤器的形式提供了另一种查询功能。过滤器在概念上类似于查询，但是它们有非常快的执行速度，这种快的执行速度主要有以下两个原因：

过滤器不会计算相关度的得分，所以它们在计算上更快一些
过滤器可以被缓存到内存中，这使得在重复的搜索查询上，其要比相应的查询快出许多。
比如查询是否存在字段age的doc 可以用query 也可以使用过滤过滤放在bool中

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query":{
  "bool":{
   "filter": {
     "exists" : {
       "field":"age"
      }
    }
   }
   }
}';

返回的结果中 _score都为0 比如

{
        "_index" : "user",
        "_type" : "info",
        "_id" : "7",
        "_score" : 0.0,
        "_source" : {
          "id" : "7",
          "country" : "中国",
          "provice" : "湖南省",
          "city" : "长沙市",
          "age" : "18",
          "name" : "张三",
          "desc" : "张三来自长沙市 是公务员一名"
        }
      }

4》聚合

默认数字类型比如 integer float long都可以直接聚合如果是字符串需要聚合必须设置属性 fielddata=true 假设我使用国家进行聚合（group by）
首先修改 mapping 添加映射（删除索引重建重新导入数据）

               "country" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word",
                    "fielddata":true
                },"provice" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word",
                    "fielddata":true
                },"city" : {
                    "type" : "string",
                    "analyzer" : "ik_max_word",
                    "fielddata":true
                }

执行简单的聚合（按某个字段分组每个分组有多少个元素）注意指定分词器否则逐个单词来分组

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      }
    }
  }
}';

最后聚合结果为：

 "aggregations" : {
    "group_by_country" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "美国",
          "doc_count" : 6
        },
        {
          "key" : "中国",
          "doc_count" : 5
        }
      ]
    }
  }

类似于sql语句

SELECT country as key,COUNT(*) as doc_count from user_info GROUP BY country ORDER BY COUNT(*) DESC

上面的group_by_country是给当前分组取一个名字可以多个分组下面结果会出现两个分组结果互不影响

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      }
    },
    "group_by_provice": {
      "terms": {
        "field": "provice"
      }
    }
  }
}';

上面size：0表示只是获取分组的结果类似于solr中的facets

如果设置了size:数字返回结果中还会带出具体分组的具体数据类似于solr的聚合

es的聚合支持嵌套比如按国家分组后再按城市分组 (安装国家分组各个分组内部的数据再按照城市分组 )

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      },
      "aggs":{
        "group_by_age":{
          "terms":{
             "field":"city"
           }
        }
	  }
    }
  }
}';

也可以在嵌套的聚合中使用聚合函数获取平均值最大值或者最小值
分组获取每组平均年龄按照平均年龄大到小排序支持max min sum 等聚合

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      },
      "aggs":{
        "avg_age":{
          "avg":{
             "field":"age"
           }
        }
	  }
    }
  }
}';

支持按照范围值进行分组比如按照国家分组后按照每个国家的年龄段分组

curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      },
      "aggs":{
        "group_by_age_range":{
          "range": {
			"field": "age",
			"ranges": [
			  {
				"from": 10,
				"to": 20
			  },
			  {
				"from": 20,
				"to": 40
			  },
			  {
				"from": 40,
				"to": 100
			  }
			]
		  }
        }
	  }
    }
  }
}';

二。使用命令搜索

java操作搜索的api

package es;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;

import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.StringTerms.Bucket;
import org.elasticsearch.search.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.transport.client.PreBuiltTransportClient;

/**
 * 之前的 /user/info数据为例
 * @author jiaozi
 *
 */
public class Search {
	/**
	 * 查询所有的 的doc
	 * [root@node1 ~]# curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
> {
>   "query":{}
> }'
{
  "hits" : {
    "total" : 1,
    "max_score" : 0.5377023,
    "hits" : [
      {
        "_index" : "user",
        "_type" : "info",
        "_id" : "7",
        "_score" : 0.5377023,
        "_source" : {
          "id" : "7",
          "country" : "中国",
          "provice" : "湖南省",
          "city" : "长沙市",
          "age" : "18",
          "name" : "张三",
          "desc" : "张三来自长沙市 是公务员一名"
        }
      }
    ]
  }
}
上面的结果是  hits里有多个hits 代码也是一样  hits里有source
	 */
	public static void search(){
		SearchResponse searchResponse = client.prepareSearch("user")
			.setTypes("info")
			.addSort("age", SortOrder.ASC)
			.setFrom(0)
			.setSize(5)
			.get();
		SearchHit[] hits = searchResponse.getHits().getHits();
		for (int i = 0; i < hits.length; i++) {
			System.out.println(hits[i].getSource());
		}
	}
	/**
	 * curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "query" : {
        "term" : { "desc" : "来自" }
    },
    "_source":["name", "desc"]
}';
	 */
	public static void searchTerms(){
		SearchResponse searchResponse = client.prepareSearch("user")
			.setTypes("info")
			.addSort("age", SortOrder.ASC)
			//QueryBuilders可以指定其他 比如 match或者match_phase或者 regexp 或者prefix或者其他
			.setQuery(QueryBuilders.termQuery("desc", "来自")) //搜索 有得分
			//.setQuery(QueryBuilders.rangeQuery("age").lte(30)) //范围查询
			//.setQuery(QueryBuilders.regexpQuery("desc", "来自"))//正则
			//.setQuery(QueryBuilders.prefixQuery("desc", "张三"))//前缀
			//.setQuery(QueryBuilders.matchQuery("desc", "张三 来自"))//match
			//.existsQuery("desc")  //exists 是否存在字段
			//.setPostFilter(QueryBuilders.termQuery("desc", "来自")) //过滤没得分
			.setFrom(0)
			.setSize(5)
			.get();
		SearchHit[] hits = searchResponse.getHits().getHits();
		for (int i = 0; i < hits.length; i++) {
			System.out.println(hits[i].getSource());
		}
	}
	/**
	 * 等价于 
	 * curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
		{
		  "query":{
		  "bool":{
		   "must": {
		     "range" : {
		       "age" : {"gte":20}
		      }
		    },
		   "must": {
		     "range" : {
		       "age" : {"lte":30}
		      }
		     }
		   }
		   }
		}';
	 */
	public static void searchBool(){
		SearchResponse searchResponse = client.prepareSearch("user")
				.setTypes("info")
				.setQuery(QueryBuilders
						.boolQuery()
						.must(QueryBuilders.rangeQuery("age").lte(40))
						.must(QueryBuilders.rangeQuery("age").gte(20))
						//.mustNot(queryBuilder)
						//.should(queryBuilder)
						)
				.get();
		SearchHit[] hits = searchResponse.getHits().getHits();
		for (int i = 0; i < hits.length; i++) {
			System.out.println(hits[i].getSource());
		}
	}
	/**
	 * 聚合 
	 * curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
		{
		  "size": 0,
		  "aggs": {
		    "group_by_country": {
		      "terms": {
		        "field": "country"
		      }
		    }
		  }
		}';
	 */
	public static void aggs(){
		SearchResponse searchResponse = client.prepareSearch("user")
				.addAggregation(AggregationBuilders.terms("group_by_country").field("country"))
				.setSize(4)
				.get();
		StringTerms terms = searchResponse.getAggregations().get("group_by_country");
		List<Bucket> buckets = terms.getBuckets();
		for (int i = 0; i < buckets.size(); i++) {
			Bucket bucket = buckets.get(i);
			System.out.println(bucket.getKey()+"----"+bucket.getDocCount());
		}
		SearchHit[] hits = searchResponse.getHits().getHits();
		for (int i = 0; i < hits.length; i++) {
			System.out.println(hits[i].getSource());
		}
	}
	/**
	 * curl -XPOST '192.168.58.147:9200/user/_search?pretty' -d '
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      },
      "aggs":{
        "avg_age":{
          "avg":{
             "field":"age"
           }
        }
	  }
    }
  }
}';
	 */
	public static void aggsAvgs(){
		SearchResponse searchResponse = client.prepareSearch("user")
				.addAggregation(AggregationBuilders
						.terms("group_by_country")
						.field("country")
						.subAggregation(AggregationBuilders.avg("avg_age").field("age"))
						)
				.get();
		StringTerms terms = searchResponse.getAggregations().get("group_by_country");
		List<Bucket> buckets = terms.getBuckets();
		for (int i = 0; i < buckets.size(); i++) {
			Bucket bucket = buckets.get(i);
			Avg st=bucket.getAggregations().get("avg_age");
			System.out.println(bucket.getKey()+"----"+bucket.getDocCount());
			System.out.println(st.getValue());
		}
		
	}
	
	public static void main(String[] args) {
		aggsAvgs();
	}
	static TransportClient client;
	static{
		try {
			client=getClient();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 获取客户端操作对象
	 * @return
	 * @throws UnknownHostException 
	 */
	public static TransportClient getClient() throws UnknownHostException{
		Settings settings = Settings.builder()
		        .put("cluster.name", "my_cluster_name")
		        //.put("index.analysis.analyzer.default.type","ik_max_word")
		        .build();
		TransportClient client = new PreBuiltTransportClient(settings)
		        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("192.168.58.147"), 9300));
		return client;
	}
}

查看全文

相关阅读:
假如时光倒流，我会这么学习Java
一位资深程序员大牛给予Java初学者的学习路线建议
 Java基础部分全套教程.
假如时光倒流，我会这么学习Java
Window Location对象
 Window Screen对象
 Window
easyui datagrid 清除缓存方法
 easyui tree扩展tree方法获取目标节点的一级子节点
 JavaScript 对象

原文地址：https://www.cnblogs.com/liaomin416100569/p/9331156.html