ElasticSearch07_搜索

最新推荐文章于 2024-06-23 10:23:54 发布
最新推荐文章于 2024-06-23 10:23:54 发布
阅读量196 收藏
点赞数 2
分类专栏： elasticsearch 文章标签： elasticsearch 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30815637/article/details/99542575
版权

搜索管理

环境准备

创建映射
{
	"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"
		}
	}
}
插入原始数据

POSTMan 操作即可.

# 创建映射：
post：http://localhost:9200/video/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/video/doc/1
{
    "name": "Bootstrap开发",
    "description": "Bootstrap是由Twitter推出的一个前台页面开发框架，是一个非常流行的开发框架，",
    "studymodel": "201002",
    "price":38.6,
    "timestamp":"2018-04-25 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
}
http://localhost:9200/video/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"
}
简单测试

在这里插入图片描述

DSL搜索

DSL 搜索是 ES 提出的基于 JSON 的搜搜方式, 在搜索时传入特定的 JSON 格式的数据来完成不同的搜索需求.

DSL 比 URL 方式功能更加强大, 建议在项目中使用 DSL 方式来完成搜索.

查询所有文档
url 方式

查询所有索引库中文档:

post http://localhost:9200/_search

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

post http://localhost:9200/video/doc/_search

{ 
  "query": {
      "match_all": {}
  },
   #指定结果中包含哪些字段
   "_source" : ["name","studymodel"]
}

在这里插入图片描述

Java Client 方式
@Test
public void testQueryAll() throws IOException {
    SearchRequest request = new SearchRequest("video");
    request.types("doc");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //原字段过滤
    builder.fetchSource(new String[]{"name","description"},new String[]{});
    request.source(builder);
    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}
分页查询
url方式

ES 支持分页查询, 传入两个参数 : from 和 size

form: 起始文档的下标, 从 0 开始

size: 查询的文档数量

POST : http://localhost:9200/video/doc/_search

{ 
	"from": 0,
	"size": 1,
	"query": {
		"match_all": {}
	},
	"_source": ["name","description"]
}
Java Client 方式
@Test
public void testPageQuery() throws IOException {
    SearchRequest request = new SearchRequest("video");
    request.types("doc");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    builder.from(0);
    builder.size(2);
    //原字段过滤
    builder.fetchSource(new String[]{"name","description"},new String[]{});
    request.source(builder);
    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}
Term Query

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

url 方式

post http://localhost:9200/video/doc/_search

{ 
	"query": {
		"term" :{
			"name": "spring"
		}
	},
	"_source": ["name","description"]
}
Java Client
@Test
public void testTermQuery() throws IOException {
    SearchRequest request = new SearchRequest("video");
    request.types("doc");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //原字段过滤
    builder.query(QueryBuilders.termQuery("name", "spring"));
    request.source(builder);
    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}
根据 id 精确匹配

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

url 方式

post ： http://127.0.0.1:9200/video/doc/_search

{ 
    "query": {
        "ids" :{
            "type": "doc",
            "values": ["1","2"]
        }
    },
    "_source": ["name","description"]
}
Java Client 方式
@Test
    public void testIds() throws IOException {
        SearchRequest request = new SearchRequest("video");
        request.types("doc");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //多个id
        String[] split = new String[]{"1","2"};
        List<String> idList = Arrays.asList(split);
        //原字段过滤 注意: 使用的是 termsQuery 方法 不是 termQuery
        builder.query(QueryBuilders.termsQuery("_id", idList));
        request.source(builder);
        //返回查询结果
        SearchResponse response = highLevelClient.search(request);
        SearchHits hits = response.getHits();
        SearchHit[] hits1 = hits.getHits();
        for (SearchHit hit : hits1){
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            //打印 _source
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            System.out.println(name);
            System.out.println(description);
        }
    }
match query

match query 全文检索, 他的搜索方式是先将搜索字符串分词, 再适应各个词条从索引中搜索.

match query 与 term query 区别是 match query 在搜索前先将搜索关键字分词, 再拿各个词语去索引中搜索.

url方式

post http://localhost:9200/video/doc/_search

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

执行过程 :

  1. 将 spring开发 分为 : spring , 开发 两个词
  2. 再使用 spring 和 开发 两个词去匹配索引中的搜索
  3. 由于设置了 operator 为 or , 因此只要有一个词匹配成功就可以返回该文档
Java Client 方式
@Test
public void testMatchQuery() throws IOException {
    SearchRequest request = new SearchRequest("video");
    request.types("doc");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //原字段过滤
    builder.query(QueryBuilders.matchQuery("description","java开发").operator(Operator.OR));
    request.source(builder);
    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}

minimum_should_match:

上面使用 oprator = or 表示只要有一个词匹配就能得分, 如果要实现三个词有两个匹配呢?

使用 minimum_should_match 可以指定文档匹配词的占比:

比如 :

{
    "query": {
        "match": {
            "description": {
                "query": "spring开发框架",
                "minium_should_match": "80%"
            }        
        }
    }
}

Spring开发框架会被分为 : Spring 开发 框架 三个词,

设置 minium_should_match : 80% 表示三个词在文档的匹配占比为 80%, 即 3*0.8=2.4 , 向上取整得 2, 表示至少有两个词在文档中就会匹配成功.

@Test
public void test_minimum_should_match() throws IOException {

    SearchRequest request = new SearchRequest("video");
    request.types("doc");

    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

    MultiMatchQueryBuilder builder = QueryBuilders
        .multiMatchQuery("description","java开发")
        .minimumShouldMatch("80%");

    searchSourceBuilder.query(builder);

    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}
multi query

上面学习的 termQuery 和 matchQuery 一次只能匹配一个 Field, 学习 multiQuery 一次可以匹配多个字段.

url 方式

发送：post http://localhost:9200/video/doc/_search

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

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

匹配多个字段时可以提升字段的 boost(权重) 来提高得分.

{ 
    "query": {
        "multi_match" : {
            "query" : "spring框架",
            "minimum_should_match": "50%",
            #name权重高于description 排在前面
            "fields": [ "name^10", "description" ]
        }
    }
}
Java Client 方式
@Test
public void test_minimum_should_match() throws IOException {

    SearchRequest request = new SearchRequest("video");
    request.types("doc");

    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

    MultiMatchQueryBuilder builder = QueryBuilders
        .multiMatchQuery("description","java开发")
        .minimumShouldMatch("80%");
    builder.field("name",10);
    searchSourceBuilder.query(builder);
    //返回查询结果
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(description);
    }
}
布尔查询

三个参数 :

must : 文档必须匹配 must 所包括的查询条件, 相当于 and

should: 文档应该匹配 should 所包括的查询条件其中的一个或者多个, 相当于 or

must_not: 文档不能匹配, 相当于 not

url 方式

POST http://localhost:9200/video/doc/_search

{
    "_source": ["name","studymodel","description"],
    "from": 0,
    "size": 1,
    "query": {
        "bool": {
            "must": [
                {
                    "nulti_match": {
                        "query": "Spring框架",
                        "mini_should_match": "50%",
                        "fields": [
                            "name*10",
                            "description"
                        ]
                    }
                },
                {
                    "term": {
                        "studymodel": "201001"
                    }
                }
            ]
        }
    }
}
Java Client 方式
@Test
public void testBoolQuery() throws IOException {
    //构建查询请求对象
    SearchRequest request = new SearchRequest("video").types("doc");
    //构建源请求条件
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //构建多域查询
    MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders
        .multiMatchQuery("程序员 java","description")
        .minimumShouldMatch("80%");
    multiMatchQueryBuilder.field("name",10);
    //构建精准查询对象
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("_id","3");
    //构建 bool 查询对象
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.must(multiMatchQueryBuilder);
    boolQueryBuilder.must(termQueryBuilder);
    //将布尔查询对象设置进请求条件中
    searchSourceBuilder.query(boolQueryBuilder);
    //设置搜索源
    request.source(searchSourceBuilder);
    SearchResponse response = highLevelClient.search(request);
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1){
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        //打印 _source
        String sourceAsString = hit.getSourceAsString();
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String description = (String) sourceAsMap.get("description");
        System.out.println(description);
    }
}
过滤器

过滤是针对搜索的结果进行过滤, 过滤器主要判断的是文档是否匹配, 不去计算和判断文档的匹配度的得分, 所以过滤器性能要比查询高, 且方便缓存, 推荐尽量使用过滤器区实现查询或者过滤器和查询共同使用.

过滤器在布尔查询中使用, 下面是在搜索结果的基础上进行过滤

range 和 term 异常只能对一个 field 设置范围过滤.

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

[外链图片转存失败(img-oVLUptnh-1565746946889)(C:\Users\15099\AppData\Roaming\Typora\typora-user-images\1564903715958.png)]

// 布尔查询使用过滤器
@Test
public void testFilter() throws IOException {
    SearchRequest searchRequest = new SearchRequest("xc_course");
    searchRequest.types("doc");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //source源字段过滤
    searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "description"},
                                    new String[]{});
    searchRequest.source(searchSourceBuilder);
    //匹配关键字
    MultiMatchQueryBuilder multiMatchQueryBuilder = 
        QueryBuilders.multiMatchQuery("spring框架", "name", "description");
    //设置匹配占比
    multiMatchQueryBuilder.minimumShouldMatch("50%");
    //提升另个字段的Boost值
    multiMatchQueryBuilder.field("name", 10);
    searchSourceBuilder.query(multiMatchQueryBuilder);
    //布尔查询
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.must(searchSourceBuilder.query());
    //过虑
    boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel", "201001"));
    boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(60).lte(100));
    SearchResponse searchResponse = highLevelClient.search(searchRequest);
    SearchHits hits = searchResponse.getHits();
    SearchHit[] searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        String sourceAsString = hit.getSourceAsString();
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String studymodel = (String) sourceAsMap.get("studymodel");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(studymodel);
        System.out.println(description);
    }
}
排序

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

url 方式

POST http://localhost:9200/video/doc/_search

{
    "_source": ["name","studymodel","description","price"],
    "query": {
        "bool": {
            "filter": [
                {
                    "range": {
                        "price": {
                            "gte": 0,
                            "lte": 100
                        }                        
                    }
                }
            ]
        }
    },
    "sort": [
        {
            "studymodel": "desc"
        },
        {
            "price": "asc"
        }
    ]
}
Java Client 方式
@Test
public void testSort() throws IOException {
    SearchRequest searchRequest = new SearchRequest("video");
    searchRequest.types("doc");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //source源字段过虑
    searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "description"},
                                    new String[]{});
    searchRequest.source(searchSourceBuilder);
    //布尔查询
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    //过虑
    boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
    // 排序
    searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));
    searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));
    SearchResponse searchResponse = highLevelClient.search(searchRequest);
    SearchHits hits = searchResponse.getHits();
    SearchHit[] searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        String index = hit.getIndex();
        String type = hit.getType();
        String id = hit.getId();
        float score = hit.getScore();
        String sourceAsString = hit.getSourceAsString();
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        String name = (String) sourceAsMap.get("name");
        String studymodel = (String) sourceAsMap.get("studymodel");
        String description = (String) sourceAsMap.get("description");
        System.out.println(name);
        System.out.println(studymodel);
        System.out.println(description);
    }
}
高亮显示

高亮显示可以将搜索结果一个或多个字进行突出显示, 以便向用户匹配关键字的位置.

在搜索语句中添加 highlight 即可实现, 如下 :

url 方式

post： http://127.0.0.1:9200/video/doc/_search

{
    "_source": [
        "name", 
        "studymodel", 
        "description", 
        "price"
    ], 
    "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": [
        {
            "price": "asc"
        }
    ], 
    "highlight": {
        "pre_tags": [
            "<tag1>"
        ], 
        "post_tags": [
            "</tag2>"
        ], 
        "fields": {
            "name": { }, 
            "description": { }
        }
    }
}
Java Client 方式
@Test
public void testHighlight() throws IOException {
    SearchRequest searchRequest = new SearchRequest("video");
    searchRequest.types("doc");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //source源字段过滤
    searchSourceBuilder.fetchSource
        (new String[]{"name", "studymodel", "price", "description"},new String[]{});
    searchRequest.source(searchSourceBuilder);
    //匹配关键字
    MultiMatchQueryBuilder multiMatchQueryBuilder = 
        QueryBuilders.multiMatchQuery("开发","name", "description");
    searchSourceBuilder.query(multiMatchQueryBuilder);
    //布尔查询
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.must(searchSourceBuilder.query());
    //过虑
    boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
    //排序
    searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));
    searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));
    //高亮设置
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.preTags("<font color='red'>");//设置前缀
    highlightBuilder.postTags("</font>");//设置后缀
    // 设置高亮字段
    highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
    highlightBuilder.fields().add(new HighlightBuilder.Field("description"));

    searchSourceBuilder.highlighter(highlightBuilder);

    SearchResponse searchResponse = highLevelClient.search(searchRequest);

    SearchHits hits = searchResponse.getHits();
    SearchHit[] searchHits = hits.getHits();

    for (SearchHit hit : searchHits) {
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        //名称
        String name = (String) sourceAsMap.get("name");
        String description = (String)sourceAsMap.get("description");
        //取出高亮字段内容
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if (highlightFields != null) {
            HighlightField nameField = highlightFields.get("name");
            HighlightField descriptionField = highlightFields.get("description");

            if (descriptionField != null) {
                Text[] fragments = descriptionField.getFragments();
                StringBuffer stringBuffer = new StringBuffer();
                for (Text str : fragments) {
                    stringBuffer.append(str.string());
                }
                description = stringBuffer.toString();
            }
            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);
        System.out.println(description);
    }
}
ields.get("name");
            HighlightField descriptionField = highlightFields.get("description");

            if (descriptionField != null) {
                Text[] fragments = descriptionField.getFragments();
                StringBuffer stringBuffer = new StringBuffer();
                for (Text str : fragments) {
                    stringBuffer.append(str.string());
                }
                description = stringBuffer.toString();
            }
            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);
        System.out.println(description);
    }
}
lf_yyyy
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch的一些概念
achang07的博客
03-28 2719
ElasticSearch是个天然分布式的搜索引擎，有一些核心概念与传统的数据库知识区别很大，这里做一下记录和整理。 分布式相关 集群 一个集群cluster由一个或者多个节点组成，具有相同的cluster.name，协同工作，分项数据和负载。当有新的节点加入或者删除了一个节点时，集群回感知到并能够平衡数据。 ElasticSearch中可以监控很多信息，有一个最重要的就是集群健康。集群健...
第四章 ElasticSearch基础搜索（二）
hankin的博客
07-20 2155
一、内置分析器 前面说过，每个被分析字段经过一系列的处理步骤： 1）字符过滤：使用字符过滤器转变字符。 2）文本切分为分词：将文本切分为单个或多个分词。 3）分词过滤：使用分词过滤器转变每个分词。 每个分析器基本上都要包含上面三个步骤至少一个。其中字符过滤器可以为0个，也可以为多个，分词器则必须，但是也只能有一个，分词过滤器可以为0个或者多个。Elasticsearch已经为我们内置了很多的字符过滤器、分词器和分词过滤器，以及分析器。不过常用的就是那么几个。 1、字符过滤器Character f
Elasticsearch之四种查询类型和搜索原理（博主推荐）
weixin_30362233的博客
02-24 2248
　　Elasticsearch Client发送搜索请求，某个索引库，一般默认是5个分片（shard）。 　　它返回的时候，由各个分片汇总结果回来。 　　官网API https://www.elastic.co/guide/en/elasticsearch/client/java-api/2.4/index.html ...
ElasticSearch 9种查询搜索管理
guohao_Kwok的博客
04-27 4765
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> ...
Elasticsearch学习，请先看这一篇！
热门推荐
铭毅天下Elasticsearch
08-18 23万+
题记：Elasticsearch研究有一段时间了，现特将Elasticsearch相关核心知识、原理从初学者认知、学习的角度，从以下9个方面进行详细梳理。欢迎讨论……0. 带着问题上路——ES是如何产生的？（1）思考：大规模数据如何检索？如：当系统数据量上了10亿、100亿条的时候，我们在做系统架构的时候通常会从以下角度去考虑问题： 1）用什么数据库好？(mysql、sybase、oracle、达
ElasticSearch搜索
清晨
09-02 1260
ElasticSearch搜索 一、简介 二、相关概念 三、工作机制 四、安装、配置、部署 五、Java Api 六、更多应用 七、其它
Elastic Search
baidu_38900596的博客
10-22 110
Elastic Search进阶及实际应用 一、基础知识 核心概念 索引（index）：相当于关系型数据库的数据库 类型（type）：相当于关系型数据库的表 映射（mapping）：相当于关系型数据库的表结构 文档（document）：相当于数据库的行（记录） 二、Java客户端操作Elasticsearch 依赖 环境变量设置 添加索引 删除索引 创建映射 [外链 创建文档 修改文档 删除文档 查询文档（全部） 查询文档（部分）
2天学习ElasticSearch教程（3G）
04-11
---05Lucene的API介绍-复杂查询.mp4┃---06ElasticSearch简介.mp4┃---07ES和Solr的对比.mp4┃---08CentOS7的安装.mp4┃---09CentOS7的特殊命令.mp4┃---10keepalived说明.mp4┃---11虚拟keepalive
SpringBoot整合ElasticSearch实现电商高性能搜索引擎
06-13
Elasticsearch 简介 ...01 课程介绍02 elasticsearch 简介03 elasticsearch 使用场景04 安装elasticsearch 之前先安装jdk05 安装elasticsearch06 测试elasticsearch是否安装成功 07 安装kibana08 elasticsea
ElasticSearch分布式全文检索入门视频教程
02-11
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索...
elasticsearch python 查询的两种方法
09-18
Elasticsearch是一个强大的、基于Lucene的实时分布式搜索和分析引擎，广泛用于处理大量数据的检索和分析任务。Python由于其简洁的语法和丰富的库支持，成为与Elasticsearch集成的首选语言之一。 首先，让我们看一下...
elasticsearch-stuff:一些围绕弹性搜索的库
07-12
我们希望一切看起来都像一个字符串前缀问题 介绍 Ruby/Rails 集成担架- - 的Flex - - 提示/技巧使用 CURL 和 BASH 的 ELASTICSEARCH 开发工作流程，2013.07 表现Zachary Tong的博客，很多关于ES的好文章关于 ...
git commit撤销修改
酒无忧的博客
06-21 379
为默认，可以不用带该参数，用于重置暂存区的文件与上一次的提交(commit)保持一致，工作区文件内容保持不变。如果提交了代码，却发现有不需要提交的文件。可以用git reset指令。git reset 命令用于回退版本，可以指定退回某一次提交的版本。参数，它会删除回退点之前的所有信息。**注意：**谨慎使用。可以使用 ～数字表示。
Elasticsearch：倒数排序融合 - Reciprocal rank fusion - 8.14
Elastic 中国社区官方博客
06-21 1242
此功能处于技术预览阶段，可能会在未来版本中更改或删除。语法可能会在正式发布之前发生变化。Elastic 将努力修复任何问题，但技术预览中的功能不受官方正式发布功能的支持 SLA 约束。倒数排序融合 (reciprocal rank fusion - RRF) 是一种将具有不同相关性指标的多个结果集组合成单个结果集的方法。RRF 无需调整，并且不同的相关性指标不必相互关联即可获得高质量的结果。：在今天的文章中，RFF 有别于之前版本。这个描述是从 8.14.0 开始的。在这个版本之前，请参阅 “
Git学习记录v1.0
Choleen的博客
06-16 688
这会撤销上一次的提交，但保留所有更改在你的工作区。意味着自己的更改仍然被 Git 跟踪，可以再次提交它们，或者修改之后提交。项目成员对项目做了改动并推送到服务器，我们需要将最新的改动更新到本地，这里我们来模拟一下这种情况。这将打开你的默认文本编辑器(或者你使用了*-m*,则直接创建新的提交记录并覆盖)，修改并保存。每次代码提交的时候都会生成一条记录，其中就会包含自己配置的用户名和邮箱。查看整个项目的版本提交记录，大多数情况下，看的都是自己的记录。会丢失你自上一次提交以来的所有未提交的更改。
Elasticsearch 使用误区之一——将 Elasticsearch 视为关系数据库！
最新发布
铭毅天下Elasticsearch
06-23 544
Elasticsearch 是一个强大的工具，尤其在全文检索、实时分析、机器学习、地理数据应用、日志和事件数据分析、安全信息和事件管理等场景有大量的应用。然而，Elastic Stack 技术栈的选型及应用效能取决于正确的使用方式。选型错误或者误用 Elasticsearch 可能会导致扩展性问题、性能问题（如为解决一个问题使用非常复杂的脚本导致性能极差）等，从而使整体体验感变差。所以，本文区别于...
.git目录解读
qq_62311779的博客
06-18 619
info/exclude 文件提供了一种在本地仓库中忽略文件或目录的方法，而不需要创建或修改 .gitignore 文件。在 .git 目录中，info 子目录包含一个名为 exclude 的文件，它的作用类似于 .gitignore 文件。# 忽略所有日志文件 *.log # 忽略特定的临时目录 /tmp # 忽略特定的配置文件 config.yaml。info/exclude 文件的内容格式与 .gitignore 文件相同。.git/info/exclude 文件的内容示例。
Elasticsearch match 查询：全文搜索
Dxy1239310216的博客
06-21 474
查询的工作原理和使用方法，你可以更好地利用 Elasticsearch 进行搜索和数据分析。在实际应用中，你可能需要根据你的具体需求选择合适的查询变体，并进行适当的优化以获得更好的性能和结果质量。查询的一个关键特点是它使用了 Elasticsearch 的分析器（Analyzer）来处理查询字符串和文档字段。它提供了全文搜索、结构化搜索、分析以及近实时搜索的功能。查询是 Elasticsearch 中最常用的查询之一，它用于执行全文搜索。该查询会分析查询字符串，并在倒排索引中查找与查询字符串匹配的文档。
Elasticsearch Range 查询：范围搜索
Dxy1239310216的博客
06-22 488
Elasticsearch 的range查询是一种强大而灵活的工具，用于根据字段的数值或日期范围搜索文档。通过正确地使用它，你可以轻松地在你的 Elasticsearch 索引中执行各种类型的范围搜索。
java es score_关于elasticsearch function_score的使用
06-09
Elasticsearch的function_score查询可以通过多种方式影响搜索结果的相关性得分。它允许您使用一组函数来修改给定查询的得分，以便更好地匹配需要的结果。 以下是一些使用function_score查询的示例： 1. 使用boost_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值