elasticsearch 搜索管理

逃离我推掉我的手 2022-04-10 11:08 254阅读 0赞

1.创建映射

post：http://localhost:9200/xc\_course/doc/\_mapping

{
    	"properties": {
    		"description": {
    			"type": "text",
    			"analyzer": "ik_max_word",
    			"search_analyzer": "ik_smart"
    			
    		},
    		"name": {
    			"type": "text",
    			"analyzer": "ik_max_word",
    			"search_analyzer": "ik_smart"
    			
    		},
    		"pic":{
    			"type":"text",
    			"index":false
    			
    		},
    		"price": {
    			"type": "float"
    			
    		},
    		"studymodel": {
    			"type": "keyword"
    		},
    		"timestamp": {
    			"type": "date",
    			"format": "yyyy‐MM‐dd HH:mm:ss||yyyy‐MM‐dd||epoch_millis"
    		}
    	}
    }

添加查询数据

http://localhost:9200/xc_course/doc/1
    
    {
    	
    		"name": "Bootstrap开发",
    		"description": "Bootstrap是由Twitter推出的一个前台页多种页面效果。此开发框架包含了大量的CSS、JS程序代码，可的实现一个不受浏览器限制的精美界面效果。",
    		"studymodel": "201002",
    		"price":38.6,
    		"timestamp":"2018‐04‐25 19:11:35",
    		"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDE"
    	
    }

http://localhost:9200/xc_course/doc/2
    
    
    
    {
    	
    		"name": "java编程基础",
    		"description": "java语言是世界第一编程语言，在软件开发领域使用人数最多。",
    		"studymodel": "201001",
    		"price":68.6,
    		"timestamp":"2018‐03‐25 19:11:35",
    		"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
    	
    }

http://localhost:9200/xc_course/doc/3
    
    {
    	
    	"name": "spring开发基础",
    	"description": "spring 在java领域非常流行，java程序员都在用。",
    	"studymodel": "201001",
    	"price":88.6,
    	"timestamp":"2018‐02‐24 19:11:35",
    	"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
    	
    }

添加完数据后我们使用head 插件 查看是否插入成功

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70][]

### 简单搜索 ###

查询所有索引库的文档。

发送：post http://localhost:9200/\_search

查询指定索引库指定类型下的文档。

发送：post http://localhost:9200/xc\_course/doc/\_search

{
    	"query":{
    		"match_all": {}
    	},
    	"_source" : [
    		"name","studymodel"
    		]
    }

\_source：source源过虑设置，指定结果中所包括的字段有哪些。

查询的结果为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70 1][]

## ##

结果说明：

took：本次操作花费的时间，单位为毫秒。

timed\_out：请求是否超时

\_shards：说明本次操作共搜索了哪些分片

hits：搜索命中的记录

hits.total ： 符合条件的文档总数

hits.hits ：匹配度较高的前N个文档

hits.max\_score：文档匹配得分，这里为最高分

\_score：每个文档都有一个匹配度得分，按照降序排列。

\_source：显示了文档的原始内容。

java client

## ##

### 分页查询 ###

ES支持分页查询，传入两个参数：from和size。

form：表示起始文档的下标，从0开始。size：查询的文档数量。

发送：post http://localhost:9200/索引/type/\_search

{
    	"from":0,
    	"size":"2",
    	"query":{
    		"match_all": {}
    	},
    	"_source" : [
    		"name","studymodel"
    		]
    }

java client

### Term Query ###

Term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词。

发送：post http://localhost:9200/索引/type/\_search

{
    	"from":0,
    	"size":"2",
    	"query":{
    		"term":{
    			"name":"spring"
    		}
    	},
    	"_source" : [
    		"name","studymodel"
    		]
    }

JavaClient：

### 根据id精确匹配 ###

ES提供根据多个id值匹配的方法：

post： http://127.0.0.1:9200/索引/type/\_search

{
    	"from":0,
    	"size":"2",
    	"query":{
    		"ids":{
    			"type":"doc",
    			"values":["1","2","3"]
    		}
    	},
    	"_source" : [
    		"name","studymodel"
    		]
    }

java client

### match Query ###

match Query即全文检索，它的搜索方式是先将搜索字符串分词，再使用各各词条从索引中搜索。

match query与Term query区别是match query在搜索前先将搜索关键字分词，再拿各各词语去索引中搜索。

发送：post http://localhost:9200/索引/type/\_search

{
    	"query":{
    		"match":{
    				"description":{
    					"query" :"spring开发",
    					"operator" : "or"
    				}
    		}
    	}
    }

query：搜索的关键字，对于英文关键字如果有多个单词则中间要用半角逗号分隔，而对于中文关键字中间可以用逗号分隔也可以不用。

operator：or 表示 只要有一个词在文档中出现则就符合条件，and表示每个词都在文档中出现则才符合条件。

### minimum\_should\_match ###

operator = or ,只要有一个词匹配上就能查询出来,但是如果要提高搜索的精确性, 需要搜索到俩三个词才能搜索出来,使用minimum\_should\_match可以指定文档匹配词的占比：搜索词语如下

{
    	"query":{
    		"match":{
    				"description":{
    					"query" :"spring开发",
    					"minimum_should_match": "80%"
    				}
    		}
    	}
    }

设置"minimum\_should\_match": "80%"表示，三个词在文档的匹配占比为80%，即3\*0.8=2.4，向上取整得2，表示至少有两个词在文档中要匹配成功。

java client

## multi Query ##

*termQuery和matchQuery一次只能匹配一个Field，*multi Query 则可以多列匹配

例子：发送：post http://localhost:9200/xc\_course/doc/\_search

拿关键字 “spring css”去匹配name 和description字段。

{
    	"query":{
    	"multi_match":{
    			"query" :"spring css",
    			"minimum_should_match": "50%",
    			"fields": [ "name", "description" ]
    		}
    	}
    }

提升boost

匹配多个字段时可以提升字段的boost（权重）来提高得分

{
    	"query":{
    	"multi_match":{
    			"query" :"spring 框架",
    			"minimum_should_match": "50%",
    			"fields": [ "name", "description^10" ]
    		}
    	}
    }

java client

### 布尔查询 ###

三个参数：

must：文档必须匹配must所包括的查询条件，相当于 “AND”

should：文档应该匹配should所包括的查询条件其中的一个或多个，相当于 "OR"

must\_not：文档不能匹配must\_not所包括的该查询条件，相当于“NOT”

{
    	"query":{
    	
    		
    		"bool":{
    			"must":[{
    					"multi_match":{
    						"query":"spring框架",
    						 "minimum_should_match":"50%",
    						 "fields":[ "name", "description" ]
    					}
    			},{
    				"term":{"studymodel" : "201001"}
    			}]
    		}
    	}
    }

java client

### 过滤器 ###

过虑是针对搜索的结果进行过虑，过虑器主要判断的是文档是否匹配，不去计算和判断文档的匹配度得分，所以过虑器性能比查询要高，且方便缓存，推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用。过虑器在布尔查询中使用，下边是在搜索结果的基础上进行过虑：

{
    	"query":{
    		"bool":{
    			"must":[{
    					"multi_match":{
    						"query":"spring框架",
    						 "minimum_should_match":"50%",
    						 "fields":[ "name", "description" ]
    					}
    			}],
    			"filter":[{
    				"term":{ "studymodel": "201001" }
    			},{
    				"range":{
    					"price":{
    						"gte":60,
    						"lte":100
    					}
    				}
    			}]
    			
    			
    		}
    	}
    }

java client

import org.elasticsearch.action.DocWriteResponse;
    import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
    import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
    import org.elasticsearch.action.delete.DeleteRequest;
    import org.elasticsearch.action.delete.DeleteResponse;
    import org.elasticsearch.action.get.GetRequest;
    import org.elasticsearch.action.get.GetResponse;
    import org.elasticsearch.action.index.IndexRequest;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.action.search.SearchRequest;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.action.update.UpdateRequest;
    import org.elasticsearch.action.update.UpdateResponse;
    import org.elasticsearch.client.IndicesClient;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.MultiMatchQueryBuilder;
    import org.elasticsearch.index.query.Operator;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.rest.RestStatus;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.SearchHits;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import javax.annotation.Resource;
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    @SpringBootTest(classes = SearchApplication.class)
    @RunWith(SpringRunner.class)
    public class TestES {
    
        @Resource
        RestHighLevelClient client;
    
        @Resource
        RestClient restClient;
    
    
        @Test
        public void testFilter() throws IOException {
            //搜索请求
            SearchRequest searchRequest = new SearchRequest("xc_course");
            searchRequest.types("doc");
    
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
    //       源数据封装
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},new String[]{} );
    
            //匹配关键字
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框架", "name", "description");
    
            // 设置匹配比
            multiMatchQueryBuilder.minimumShouldMatch("50%");
    
            //提升另类字段boots
            multiMatchQueryBuilder.field("name", 10);
    
    
    
    
            //boolean 查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(multiMatchQueryBuilder);    //设置字符匹配器
            //过滤筛选
            boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel", "201001"));
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(60).lte(100));
    
    
            //绑定boolean 查询器
            searchSourceBuilder.query(boolQueryBuilder);
    
    
            searchRequest.source(searchSourceBuilder);
    
            SearchResponse searchResponse = client.search(searchRequest);
    
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHits = hits.getHits();
            for(SearchHit hit:searchHits){
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                System.out.println(sourceAsMap);
            }
    
        }
    
    }

查询结果 为

![20190107091249365.png][]

### 排序 ###

可以在字段上添加一个或多个排序，支持在keyword、date、float等类型上添加，text类型的字段上不允许添加排序。

发送 POST http://localhost:9200/xc\_course/doc/\_search

过虑0--10元价格范围的文档，并且对结果进行排序，先按studymodel降序，再按价格升序

{
    	"query":{
    		"bool":{
    			"filter":[{
    				"range":{
    					"price":{
    						"gte":0,
    						"lte":100
    					}
    				}
    			}]
    			
    			
    		}
    	},
    	"sort":[{
    		"studymodel": "desc"
    	},{
    		"price":"asc"
    	}]
    }

java client :

查询结果为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70 2][]

### 高亮 ###

高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置。在搜索语句中添加highlight即可实现，如下：

{
    	"query":{
    		"bool":{
    			"must":[{
    				"multi_match" : {
    					"query" : "开发框架",
    					"minimum_should_match": "50%",
    					"fields": [ "name^10", "description" ],
    					"type":"best_fields"
    					
    				}
    			}],
    			"filter":[{
    				"range":{
    					"price":{
    						"gte":0,
    						"lte":100
    					}
    				}
    			}]
    			
    			
    		}
    	},
    	"sort":[{
    		"studymodel": "desc"
    	},{
    		"price":"asc"
    	}],
    	"highlight":{
    		"pre_tags": ["<tag1>"],
    		"post_tags": ["</tag2>"],
    		"fields": {
    			"name": {},
    			"description":{}
    			}
    	}
    }

java client

import org.elasticsearch.action.DocWriteResponse;
    import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
    import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
    import org.elasticsearch.action.delete.DeleteRequest;
    import org.elasticsearch.action.delete.DeleteResponse;
    import org.elasticsearch.action.get.GetRequest;
    import org.elasticsearch.action.get.GetResponse;
    import org.elasticsearch.action.index.IndexRequest;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.action.search.SearchRequest;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.action.update.UpdateRequest;
    import org.elasticsearch.action.update.UpdateResponse;
    import org.elasticsearch.client.IndicesClient;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.text.Text;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.MultiMatchQueryBuilder;
    import org.elasticsearch.index.query.Operator;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.rest.RestStatus;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.SearchHits;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
    import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
    import org.elasticsearch.search.sort.FieldSortBuilder;
    import org.elasticsearch.search.sort.SortOrder;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import javax.annotation.Resource;
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    @SpringBootTest(classes = SearchApplication.class)
    @RunWith(SpringRunner.class)
    public class TestES {
    
        @Resource
        RestHighLevelClient client;
    
        @Resource
        RestClient restClient;
    
        @Test
        public void testHighLight() throws IOException {
            //搜索请求
            SearchRequest searchRequest = new SearchRequest("xc_course");
            searchRequest.types("doc");
    
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
    //       源数据封装
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},new String[]{} );
    
            //数据筛选
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));       //  0 <  price   < 100
    
            //字符串匹配器
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("开发框架", "name", "description");
            multiMatchQueryBuilder.minimumShouldMatch("50%");
    
            //boots 另类加重
            multiMatchQueryBuilder.field("name",10 );
            boolQueryBuilder.must(multiMatchQueryBuilder);
    
            searchSourceBuilder.query(boolQueryBuilder); // 封装字符串匹配规则
    
            //设置排序
            searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));  //  降序  大到小
            searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));   // 升序  小到大
    
    
            //设置高亮
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<tag>");//设置前缀
            highlightBuilder.postTags("</tag>");//设置后缀
            // 设置高亮字段
            highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
            searchSourceBuilder.highlighter(highlightBuilder);
    
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = client.search(searchRequest);
    
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHits = hits.getHits();
            for(SearchHit hit:searchHits){
                String name = null;
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                System.out.println(sourceAsMap);
    
    
    
    //            取出高亮内容
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                if(highlightFields!=null){
                    HighlightField nameField = highlightFields.get("name");
                    if(nameField!=null){
                        Text[] fragments = nameField.getFragments();
                        StringBuffer stringBuffer = new StringBuffer();
                        for (Text str : fragments) {
                            stringBuffer.append(str.string());
                        }
                        name = stringBuffer.toString();
                    }
                }
                System.out.println(name);
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70]: /images/20220331/a5519342eb7d4514b3c4126d6f9c3918.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70 1]: /images/20220331/358fdcf055484227b517103dd2686020.png
[20190107091249365.png]: /images/20220331/31712a5b9718441dbbf5004c85e7b478.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0MjY2_size_16_color_FFFFFF_t_70 2]: /images/20220331/43817d69442e4278879b09454caceb36.png