elasticsearch 搜索管理

最新推荐文章于 2024-04-13 21:42:12 发布
最新推荐文章于 2024-04-13 21:42:12 发布
阅读量753 收藏
点赞数
分类专栏： 后台技术 文章标签： Elasticsearch 搜索 高亮

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 插件 查看是否插入成功

 

 

简单搜索

查询所有索引库的文档。

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

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

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

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

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

 

 

查询的结果为

 

结果说明：

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

timed_out：请求是否超时

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

hits：搜索命中的记录

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

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

hits.max_score：文档匹配得分，这里为最高分

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

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

 

 

 

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.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.Date;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest(classes = SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestES {

    @Resource
    RestHighLevelClient client;

    @Resource
    RestClient restClient;

    @Test  搜索type下的全部记录
    public void getTypeAll() throws IOException {
        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");
        //搜索 封装
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchAllQuery());
        //sourse  源数据封装  param1   包含的数据    param2  排除的数据
        builder.fetchSource(new String[]{"name","studymodel"},new String[]{});

        searchRequest.source(builder);
        //查询
        SearchResponse response = client.search(searchRequest);

        SearchHits hits = response.getHits();

        SearchHit[] hits1 = hits.getHits();

        for (SearchHit documentFields : hits1) {
            String index = documentFields.getIndex();
            String type = documentFields.getType();
            String id = documentFields.getId();
            float score = documentFields.getScore();
            String sourceAsString = documentFields.getSourceAsString();

            //获取源数据
            Map<String, Object> sourceAsMap = documentFields.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);
        }
    }

}

 

 

分页查询

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

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

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

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

 

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.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.Date;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest(classes = SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestES {

    @Resource
    RestHighLevelClient client;

    @Resource
    RestClient restClient;


//    分页查询
    @Test
    public void findByPage() throws IOException {
        int page = 1;  //  2     //  (page - 1 ) * 2
        int size = 2;

        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");

        //搜索 封装
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.matchAllQuery());

        builder.from((page - 1 ) * 2);
        builder.size(size);

        //sourse  源数据封装  param1   包含的数据    param2  排除的数据
        builder.fetchSource(new String[]{"name","studymodel"},new String[]{});

        searchRequest.source(builder);
        //查询
        SearchResponse response = client.search(searchRequest);

        SearchHits hits = response.getHits();

        SearchHit[] hits1 = hits.getHits();

        for (SearchHit documentFields : hits1) {
            String index = documentFields.getIndex();
            String type = documentFields.getType();
            String id = documentFields.getId();
            float score = documentFields.getScore();
            String sourceAsString = documentFields.getSourceAsString();

            //获取源数据
            Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();

            String name = (String) sourceAsMap.get("name");
            String studymodel = (String) sourceAsMap.get("studymodel");
            System.out.println(name);
            System.out.println(studymodel);
        }
    }
}

 

Term Query

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

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

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

 

JavaClient：

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.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.Date;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest(classes = SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestES {

    @Resource
    RestHighLevelClient client;

    @Resource
    RestClient restClient;

    @Test
    public void testTermQuery() throws IOException {

        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc"); //查询doc文档


        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.termQuery("name","spring" ));//精确查询
        builder.fetchSource(new String[]{"name","studymodel"},new String[]{});


        searchRequest.source(builder);//source源字段过虑
        SearchResponse searchResponse = client.search(searchRequest);

    }
}

 

 

根据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

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.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 testFindByIds() throws IOException {

        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc"); //查询doc文档


        SearchSourceBuilder builder = new SearchSourceBuilder();

        List<String> ids = Arrays.asList(new String[]{"1", "2", "3"});
        builder.query(QueryBuilders.termsQuery("_id",ids));//精确查询
        builder.fetchSource(new String[]{"name","studymodel"},new String[]{});


        searchRequest.source(builder);//source源字段过虑
        SearchResponse searchResponse = client.search(searchRequest);

    }
}

 

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表示每个词都在文档中出现则才符合条件。

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.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 testMatchFind() throws IOException {

        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");

        //封装参数
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //封装源数据
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel"}, new String[]{});

        //分词匹配
        searchSourceBuilder.query(QueryBuilders.matchQuery("description", "spring").operator(Operator.OR));

        searchRequest.source(searchSourceBuilder);
        //查询
        SearchResponse searchResponse = client.search(searchRequest);

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

        for (SearchHit documentFields : hits1) {
            Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();

            String name = (String)sourceAsMap.get("name");

            System.out.println("-----------");
            System.out.println(name);
        }
    }
}

 

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

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.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;

//    "minimum_should_match"
    @Test
    public void testMatchMinmumShouldMatch() throws IOException {
        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");

        //封装参数
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //封装源数据
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel"}, new String[]{});

        //分词匹配
        searchSourceBuilder.query(QueryBuilders.matchQuery("description", "spring").minimumShouldMatch("80%"));

        searchRequest.source(searchSourceBuilder);
        //查询
        SearchResponse searchResponse = client.search(searchRequest);
        
    }
}

 

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

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.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 testMultiMatchAndBoots() throws IOException {
        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");

        //封装参数
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //封装源数据
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel"}, new String[]{});

        //分词匹配
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("spring框架", "name", "description").minimumShouldMatch("50%").field("name", 10));

        searchRequest.source(searchSourceBuilder);
        //查询
        SearchResponse searchResponse = client.search(searchRequest);
    }

}

 

 

布尔查询

三个参数：

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

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 testBooleanFind() throws IOException {
        //搜索请求
        SearchRequest searchRequest = new SearchRequest("xc_course");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();


        //源数据封装
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"}, new String[]{});

        //匹配关键字
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框架", "name", "description");

        multiMatchQueryBuilder.field("name",10);  //boots
        searchSourceBuilder.query(multiMatchQueryBuilder);


        //设置匹配占比
        multiMatchQueryBuilder.minimumShouldMatch("50%");

        //布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.must(QueryBuilders.termQuery("studymodel", "201001" ));

        //设置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);
        }
    }

 

 

过滤器

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

{
	"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);
        }

    }

}

查询结果 为

 

排序

可以在字段上添加一个或多个排序，支持在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 :

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.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 testSort() 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

        searchSourceBuilder.query(boolQueryBuilder); // 封装字符串匹配规则

        //设置排序
        searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));  //  降序  大到小
        searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));   // 升序  小到大

        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);
        }
    }
}

 

查询结果为

 

高亮

高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置。在搜索语句中添加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);
        }
    }
}

 

xyang_1128
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
elastic java delete_ElasticSearch Java Api -删除索引
weixin_34877373的博客
02-15 491
删除可以是删除全部索引库，也能够根据文档id删除索引库下的文档，还可以通过query查询条件删除所有符合条件的数据。1、删除全部索引库下面的例子会删除indexName索引：DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(indexName).execute().actionGet();可以根据Delet...
Java基于elasticsearch实现集群管理
08-25
Java基于Elasticsearch实现集群管理 Elasticsearch是一款功能强大且流行的搜索引擎，广泛应用于大数据搜索、...Java基于Elasticsearch实现集群管理可以提供高可用性、高性能和灵活性，满足大规模搜索和数据分析需求。
Elasticsearch Java API之清空索引
云守护的专栏
08-05 8643
package com.nerve.core.test; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.Properties; import org.elasticsearch.action.admin.cluster.state.ClusterStat
架构师系列-搜索引擎ElasticSearch（三）- Java API
最新发布
dengwei_dw的专栏
04-13 638
搭建SpringBoot工程，引入ElasticSearch相关坐标测试。
JAVA SpringBoot整合并操作ES（ElasticSearch）数据
qq_42301302的博客
10-22 6597
工作需要，在更改数据时需要维护es(ElasticSearch简称，以下均称es)数据，记录个人总结。以下只包含java对es数据操作，不包含es基础内容。 一、导入maven坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
ElasticSearch(中文检索)source总结
热门推荐
ywl470812087的博客
03-21 12万+
包含不包含这里不多讲了。 GET /lib4/user/_search { "query": { "match_all": {} }, "_source": { "includes": ["name" ,"address"], "excludes": ["age" , "birthday" ] } } 直接看看结果 { "took" : 5...
ElasticSearch7.3学习(十六)----RestHighLevelClient Java api实现索引的创建、删除、是否存在、关闭、开启
09-08 2693
注意：导入的包区别，不同的包创建索引的方式不同。博主亲身实践，具体体现在createIndexRequest.mapping()里面。读者可自行试验。可以看到上述两种方式导入的包的子类名是相同的，但是具体对索引的操作方式可能是不同的。具体的区别博主暂时还不清楚，后续若有进展再在此处更新。
django使用haystack调用Elasticsearch实现索引搜索
09-19
Django结合Haystack调用Elasticsearch实现高效的全文搜索是现代Web应用中常见的做法，特别是在处理大量数据和需要快速响应用户搜索请求的场景下。以下将详细解释这一过程的关键步骤和相关知识点。 首先，Elastic...
人工智能-项目实践-搜索引擎-SpringBoot+ElasticSearch全文搜索引擎
02-26
在本项目实践中，我们将深入探讨如何使用Spring Boot和Elasticsearch构建一个全文搜索引擎。这是一个典型的人工智能应用，其中搜索引擎是关键组件，用于处理和检索大量数据。让我们逐一解析这个项目涉及的技术点。 ...
elasticsearch-6.7.0 linux 版本
04-25
Elasticsearch（简称ES）是一款开源的、基于Lucene的搜索引擎，它以分布式、RESTful API、实时、可扩展性以及高可用性而广受欢迎。6.7.0是其历史版本之一，针对阿里云进行了优化，更适合在Linux环境中部署和运行。 ...
ElasticSearch 大数据搜索工具使用
08-28
总结来说，Elasticsearch是一个强大且灵活的大数据搜索工具，其安装和使用涉及JVM配置、索引管理和查询语法等多个方面。通过深入理解这些知识点，可以有效地利用Elasticsearch处理大规模数据的检索和分析任务。在...
Elasticsearch各个语法的JAVA实例
11-03
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。该Demo包含了大部分的java应用ES语法....
elasticsearch in action
10-30
elasticsearch in action meap版本第一章内容介绍
elasticsearch源码关于action
weixin_41871193的博客
04-21 147
package org.elasticsearch.rest.action 有 很多action 包地址 package org.elasticsearch.rest.action.search public class RestSearchAction extends BaseRestHandle // 启动时注册 public RestSearchAction(Settings settings, RestController controller) { super(settings); control
【ElasticSearch教程】--- Elasticsearch JavaApi 文档查询操作（二十）
maoye的博客
05-15 2049
Elasticsearch JavaApi 文档查询操作 在前面的restful api测试的过程中，我们使用的大量的参数提交的方式进行文档的查询操作。例如：全量查询，分页查询，模糊查询等等。 那java api其实也是提供了对应的查询操作功能的。 全量查询 全量查询就是不提交任何的查询条件直接将ES上有的文档数据一次性的查询出来。查询的核心是要构造一个org.elasticsearch.action.search.SearchRequest;对象，并且使用client.search()方法即可查询。下面是
Elastic Search之Source Filtering(过滤结果中"_source"原始文本显示哪些字段)
分享传递价值
01-15 9161
之前在 elastic search之索引和文档 一文中简单说到过，查询语句返回的json中的"_source"字段就是文档的全部原始json数据，里面包含每个字段及内容，但有时候我们可能不需要这么多字段，也可能只需要其中的某几个字段，并且返回全部字段有时也浪费，这个时候通过"_source"参数便可以设置需要返回哪些具体的字段，甚至是不需要返回，我们可以类比mysql的select特定字段，而不...
elasticsearch java 客户端之action简介
weixin_30540691的博客
03-28 118
上一篇介绍了elasticsearch的client结构，client只是一个门面，在每个方法后面都有一个action来承接相应的功能。但是action也并非是真正的功能实现者，它只是一个代理，它的真正实现者是transportAction.本篇就对action及transportAction的实现做一个简单的分析， elasticsearch中的绝大部分操作都是通过相应的action，这些ac...
ElasticSearch7.10.2中多条件查询
AK47Poi的博客
08-03 2106
今天在做项目的时候需要做ES的多条件查询，相当于sql中的： select * from table where A = 'valA' and （B = 'valB' or C = 'valC';） 一开始是这样写的： BoolQueryBuilder builders= QueryBuilders.boolQuery() .must(QueryBuilders.termQuery("IPv4_Src", typeSelection))
elasticsearch的操作类
weixin_30419799的博客
02-10 90
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse; import org.elasticsearch.action.delete.DeleteResp...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值