SpringBoot 整合 ES API操作

使用IDEA构建Maven项目，引入相关依赖

<dependencies>
        <!--SpringBoot默认使用SpringData ElasticSearch模块进行操作-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.searchbox/jest -->
        <dependency>
            <groupId>io.searchbox</groupId>
            <artifactId>jest</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
</dependencies>

创建实体，这边引入lombok插件

@Data
public class Student {
	private String name;
	private Integer age;
	private String sex;
}

这里我们采用高级 REST 客户端对象RestHighLevelClient ，进行测试API：

package com.fangdada.springbootelastic;

import com.fangdada.springbootelastic.model.Student;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.HttpHost;
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.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
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.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.index.query.TermsQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
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.SortOrder;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.Map;


@RunWith(SpringRunner.class)
@SpringBootTest
class SpringbootElasticApplicationTests {

	RestHighLevelClient client = new RestHighLevelClient(
			RestClient.builder(new HttpHost("192.168.28.129", 9200, "http"))
	);


	/**
	 * 创建一个student的索引
	 * @throws IOException
	 */
	@Test
	void contextLoads() throws IOException {
		// 创建索引 - 请求对象
		CreateIndexRequest request = new CreateIndexRequest("student");
		// 发送请求，获取响应
		CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
		boolean acknowledged = response.isAcknowledged();
		// 响应状态
		System.out.println("操作状态 = " + acknowledged);
	}


	/**
	 * 删除usr索引
	 * @throws IOException
	 */
	@Test
	void delIndex() throws IOException {
		// 创建索引 - 请求对象
		DeleteIndexRequest request = new DeleteIndexRequest("student");
		// 发送请求，获取响应
		AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
		boolean acknowledged = response.isAcknowledged();
		// 响应状态
		System.out.println("操作状态 = " + acknowledged);
	}

	/**
	 * 新建文档
	 * @throws IOException
	 */
	@Test
	void addDoc() throws IOException {
		// 新增文档 - 请求对象
		IndexRequest request = new IndexRequest();
		// 设置索引及唯一性标识
		request.index("student").id("1001");
		// 创建数据对象
		Student student = new Student();
		student.setName("zhaoyun");
		student.setAge(30);
		student.setSex("男");
		ObjectMapper objectMapper = new ObjectMapper();
		String productJson = objectMapper.writeValueAsString(student);
		// 添加文档数据，数据格式为 JSON 格式
		request.source(productJson, XContentType.JSON);
		// 客户端发送请求，获取响应对象
		IndexResponse response = client.index(request, RequestOptions.DEFAULT);
		// 打印结果信息
		System.out.println("_index:" + response.getIndex());
		System.out.println("_id:" + response.getId());
		System.out.println("_result:" + response.getResult());
	}


	/**
	 * 修改文档
	 * @throws IOException
	 */
	@Test
	void modifyDoc() throws IOException {
		// 修改文档 - 请求对象
		UpdateRequest request = new UpdateRequest();
		// 配置修改参数 根据id修改
		request.index("student").id("1001");
		// 设置请求体，对数据进行修改
		// 设置请求体，对数据进行修改
		request.doc(XContentType.JSON, "sex", "女");
		// 客户端发送请求，获取响应对象
		UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
		System.out.println("_index:" + response.getIndex());
		System.out.println("_id:" + response.getId());
		System.out.println("_result:" + response.getResult());
	}

	/**
	 * 查询文档
	 * @throws IOException
	 */
	@Test
	void findDoc() throws IOException {
		//
		// 1.创建请求对象
		GetRequest request = new GetRequest().index("student").id("1001");
		// 2.客户端发送请求，获取响应对象
		GetResponse response = client.get(request, RequestOptions.DEFAULT);
		// 3.打印结果信息
		System.out.println("_index:" + response.getIndex());
		System.out.println("_type:" + response.getType());
		System.out.println("_id:" + response.getId());
		System.out.println("source:" + response.getSourceAsString());
	}

	/**
	 * 删除文档
	 * @throws IOException
	 */
	@Test
	void delDoc() throws IOException {
		//创建请求对象
		DeleteRequest request = new DeleteRequest().index("student").id("1001");
		//客户端发送请求，获取响应对象
		DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
		//打印信息
		System.out.println(response.toString());
	}

	/**
	 * 批量新增
	 * @throws IOException
	 */
	@Test
	void bulkDoc() throws IOException {
		//创建批量新增请求对象
		BulkRequest request = new BulkRequest();
		request.add(new IndexRequest().index("student").id("1001").source(XContentType.JSON, "name", "zhaoyun"));
		request.add(new IndexRequest().index("student").id("1002").source(XContentType.JSON, "name", "lisi"));
		request.add(new IndexRequest().index("student").id("1003").source(XContentType.JSON, "name", "wangwu"));
        // 客户端发送请求，获取响应对象
		BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
        // 打印结果信息
		System.out.println("took:" + responses.getTook());
		System.out.println("items:" + responses.getItems());
	}

	/**
	 * 批量删除
	 * @throws IOException
	 */
	@Test
	void bulkRmDoc() throws IOException {
		//创建批量删除请求对象
		BulkRequest request = new BulkRequest();
		request.add(new DeleteRequest().index("student").id("1001"));
		request.add(new DeleteRequest().index("student").id("1002"));
		request.add(new DeleteRequest().index("student").id("1003"));
		//客户端发送请求，获取响应对象
		BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
		//打印结果信息
		System.out.println("took:" + responses.getTook());
		System.out.println("items:" + responses.getItems());
	}

	// 查询所有索引数据
	@Test
	void searchAll() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		// 查询所有数据
		sourceBuilder.query(QueryBuilders.matchAllQuery());
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
		//输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// term查询
	@Test
	void searchTerm() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.query(QueryBuilders.termQuery("age", "30"));
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			//输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// 分页查询
	@Test
	void searchPage() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.query(QueryBuilders.matchAllQuery());
		// 分页查询
		// 当前页其实索引(第一条数据的顺序号)，from
		sourceBuilder.from(0);
		// 每页显示多少条 size
		sourceBuilder.size(2);
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			//输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// 数据排序
	@Test
	void searchSort() throws IOException {
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.query(QueryBuilders.matchAllQuery());
		// 排序
		sourceBuilder.sort("age", SortOrder.ASC);
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// 过滤字段
	@Test
	void searchFilter() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.query(QueryBuilders.matchAllQuery());
		// 查询字段过滤
		String[] excludes = {};
		String[] includes = {"name", "age"};
		sourceBuilder.fetchSource(includes, excludes);
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			// 输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	//Bool查询
	@Test
	void searchBool() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
		// 必须包含
		boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
		// 一定不含
		boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhaoyun"));
		// 可能包含
		boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));
		sourceBuilder.query(boolQueryBuilder);
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			//输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// 范围查询
	@Test
	void searchRange() throws IOException {
		SearchRequest request = new SearchRequest();
		request.indices("student");
		SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
		RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age");
		rangeQueryBuilder.gte("30");
		rangeQueryBuilder.lte("40");
		searchSourceBuilder.query(rangeQueryBuilder);
		request.source(searchSourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
	}

	// 模糊查询
	@Test
	void searchFuzzy() throws IOException {
		// 创建搜索请求对象
		SearchRequest request = new SearchRequest();
		request.indices("student");
		// 构建查询的请求体
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.query(QueryBuilders.fuzzyQuery("name","zhaoyun").fuzziness(Fuzziness.ONE));
		request.source(sourceBuilder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 查询匹配
		SearchHits hits = response.getHits();
		System.out.println("took:" + response.getTook());
		System.out.println("timeout:" + response.isTimedOut());
		System.out.println("total:" + hits.getTotalHits());
		System.out.println("MaxScore:" + hits.getMaxScore());
		System.out.println("hits========>>");
		for (SearchHit hit : hits) {
			//输出每条查询的结果信息
			System.out.println(hit.getSourceAsString());
		}
		System.out.println("<<========");
	}

	// 高亮查询
	@Test
	void searchHighlight() throws IOException {
		// 高亮查询
		SearchRequest request = new SearchRequest().indices("student");
		//2.创建查询请求体构建器
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		//构建查询方式：高亮查询
		TermsQueryBuilder termsQueryBuilder =
				QueryBuilders.termsQuery("name","lisi");
		//设置查询方式
		sourceBuilder.query(termsQueryBuilder);
		//构建高亮字段
		HighlightBuilder highlightBuilder = new HighlightBuilder();
		highlightBuilder.preTags("<font color='red'>");//设置标签前缀
		highlightBuilder.postTags("</font>");//设置标签后缀
		highlightBuilder.field("name");//设置高亮字段
		//设置高亮构建对象
		sourceBuilder.highlighter(highlightBuilder);
		//设置请求体
		request.source(sourceBuilder);
		//3.客户端发送请求，获取响应对象
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		//4.打印响应结果
		SearchHits hits = response.getHits();
		System.out.println("took::"+response.getTook());
		System.out.println("time_out::"+response.isTimedOut());
		System.out.println("total::"+hits.getTotalHits());
		System.out.println("max_score::"+hits.getMaxScore());
		System.out.println("hits::::>>");
		for (SearchHit hit : hits) {
			String sourceAsString = hit.getSourceAsString();
			System.out.println(sourceAsString);
			//打印高亮结果
			Map<String, HighlightField> highlightFields = hit.getHighlightFields();
			System.out.println(highlightFields);
		}
		System.out.println("<<::::");
	}

	// 聚合查询
	@Test
	void aggregate() throws IOException {
		// 高亮查询
		SearchRequest request = new SearchRequest().indices("student");
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.aggregation(AggregationBuilders.max("maxAge").field("age"));
		//设置请求体
		request.source(sourceBuilder);
		//3.客户端发送请求，获取响应对象
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		//4.打印响应结果
		SearchHits hits = response.getHits();
		for(SearchHit hit : hits){
			String sourceAsString = hit.getSourceAsString();
			System.out.println(sourceAsString);
		}
		System.out.println(response);
	}

	// 分组统计
	@Test
	void groupCount() throws IOException {
		// 高亮查询
		SearchRequest request = new SearchRequest().indices("student");
		SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
		sourceBuilder.aggregation(AggregationBuilders.terms("age_groupby").field("age"));
		// 设置请求体
		request.source(sourceBuilder);
		// 3.客户端发送请求，获取响应对象
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		// 4.打印响应结果
		SearchHits hits = response.getHits();
		for(SearchHit hit : hits){
			String sourceAsString = hit.getSourceAsString();
			System.out.println(sourceAsString);
		}
		System.out.println(response);
	}

}