1、ElasticSearch依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency> 

2、构建RestHighLevelClient(高级客户端)对象，实现SpringBoot和elasticSearch集成，返回一个client
在IDEA中，如何使用已经配好的ElasticSearch，将项目个ElasticSearch和SpringBoot整合在一起
首先在官网是看到

翻译：

所以一个高级的客户端（RestHighLevelClient）需要一个Rest低级客户端构造器来构建
所以我们要在定义一个配之类来提供这种功能。elasticSearch就是通过这一步和SpringBoot集成的

@Configuration
public RestHighLevelClient restHighLevelClient(){
	@Bean
	public RestHighLevelClient restHighLevelClient() {
	RestHighLevelClient client = new RestHighLevelClient(
		RestClient.builder(
			//整个new HttpHost("localhost",9200，“http”)可以配置多个
			//在集群的时候就可以配置多个
			new HttpHost("localhost", 9200, "http")));
	return client;
	}
}

ElasticSearch中的常用方法工具类封装（就是在一个类中封装了对索引的创建、删除等一系列的操作）

/**
*@Component声明这个类将被SpringIOC容器扫描装配
*/
@Component
public class ElasticSearchUtils<T> {
@Autowired
private RestHighLevelClient restHighLevelClient;

/**
* 判断索引是否存在
*/
public boolean existsIndex(String index) throws IOException {
	GetIndexRequest request = new GetIndexRequest(index);
	boolean exists = client.indices().exists(request,RequestOptions.DEFAULT);
	return exists;
}

/**
*创建索引
*/
public boolean createIndex(String index) throws IOException {
CreateIndexRequest request = new CreateIndexRequest(index);
CreateIndexResponse createIndexResponse=client.indices().create(request,RequestOptions.DEFAULT);
return createIndexResponse.isAcknowledged();
}

/**
*删除索引
*/
public boolean deleteIndex(String index) throws IOException {
	DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(index);
	AcknowledgedResponse response = client.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
	return response.isAcknowledged();
}

/**
*判断某索引下文档id是否存在
*/
public boolean docExists(String index, String id) throws IOException {
	GetRequest getRequest = new GetRequest(index,id);
	//只判断索引是否存在不需要获取_source
	//getRequest.fetchSourceContext(new FetchSourceContext(false));
	//getRequest.storedFields("_none_");
	boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
	return exists;
}

/**
*添加文档记录
*/
public boolean addDoc(String index,String id,T t) throws IOException {
	IndexRequest request = new IndexRequest(index);
	request.id(id);
	//设置超时时间
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	//将前端获取来的数据封装成一个对象转换成JSON格式放入请求中
	request.source(JSON.toJSONString(t), XContentType.JSON);
	IndexResponse indexResponse = client.index(request,RequestOptions.DEFAULT);
	RestStatus Status = indexResponse.status();
	return Status==RestStatus.OK||Status== RestStatus.CREATED;
}

/**
*根据id来获取记录
*/
public GetResponse getDoc(String index, String id) throws IOException {
	GetRequest request = new GetRequest(index,id);
	GetResponse getResponse = client.get(request,RequestOptions.DEFAULT);
	return getResponse;
}

/**
*批量添加文档记录
*/
public boolean bulkAdd(String index, List<T> list) throws IOException {
	BulkRequest bulkRequest = new BulkRequest();
	//设置超时时间
	bulkRequest.timeout(TimeValue.timeValueMinutes(2));
	bulkRequest.timeout("2m");
	for (int i =0;i<list.size();i++){
		bulkRequest.add(new IndexRequest(index).source(JSON.toJSONString(list.get(i))));
	}
	BulkResponse bulkResponse = client.bulk(bulkRequest,
	RequestOptions.DEFAULT);
	return !bulkResponse.hasFailures();
}

/**
*更新文档记录
*/
public boolean updateDoc(String index,String id,T t) throws IOException
{
	UpdateRequest request = new UpdateRequest(index,id);
	request.doc(JSON.toJSONString(t));
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	UpdateResponse updateResponse = client.update(request, RequestOptions.DEFAULT);
	return updateResponse.status()==RestStatus.OK;
}

/**
*删除文档记录
*/
public boolean deleteDoc(String index,String id) throws IOException {
	DeleteRequest request = new DeleteRequest(index,id);
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
	return deleteResponse.status()== RestStatus.OK;
}

/**
*根据某字段来搜索
*/
public void search(String index,String field ,String key,Integer from,Integer size) throws IOException {
	SearchRequest searchRequest = new SearchRequest(index);
	SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
	sourceBuilder.query(QueryBuilders.termQuery(field, key));
	//控制搜素
	sourceBuilder.from(from);
	sourceBuilder.size(size);
	//最大搜索时间。
	sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
	searchRequest.source(sourceBuilder);
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
	System.out.println(JSON.toJSONString(searchResponse.getHits()));
	}
}

以上ElasticSearchUtils<T>就是我们对索引和文档的一些增删改查的封装。

一下下是一些API的测试操作
（1）创建索引测试

@Test
public void testCreateIndex() throws IOException {
	CreateIndexRequest request = new CreateIndexRequest("索引");
	CreateIndexResponse createIndexResponse =restHighLevelClient.indices().create(request,RequestOptions.DEFAULT);
	System.out.println(createIndexResponse);
}

（2）获取索引测试

@Test
public void testExistsIndex() throws IOException {
	GetIndexRequest request = new GetIndexRequest("索引");
	boolean exists = restHighLevelClient.indices().exists(request,RequestOptions.DEFAULT);
	System.out.println(exists);
}

（3）删除索引测试

@Test
pubic void testDeleteIndexRequest() throws IOException {
	DeleteIndexRequest deleteIndexRequest = newDeleteIndexRequest("索引");
	AcknowledgedResponse response = restHighLevelClient.indices().delete(deleteIndexRequest,RequestOptions.DEFAULT);
	System.out.println(response.isAcknowledged());
}

添加文档记录测试：
创建一个实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
	private String name;
	private int age;
}

（1）添加文档记录测试

@Test
public void testAddDocument() throws IOException {
	// 创建对象
	User user = new User("UserName", UserAge);
	// 创建请求
	IndexRequest request = new IndexRequest("UserName");
	// 规则
	request.id("1");
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	request.source(JSON.toJSONString(user),XContentType.JSON);
	// 发送请求
	IndexResponse indexResponse = restHighLevelClient.index(request,RequestOptions.DEFAULT);
	System.out.println(indexResponse.toString());
	RestStatus Status = indexResponse.status();
	System.out.println(Status == RestStatus.OK || Status ==RestStatus.CREATED);
}

（2）判断某索引下文档id是否存在

@Test
public void testIsExists() throws IOException {
	GetRequest getRequest = new GetRequest("UserName","id");
	// 不获取_source上下文 storedFields
	getRequest.fetchSourceContext(new FetchSourceContext(false));
	getRequest.storedFields("_none_");
	// 判断此id是否存在！
	boolean exists = restHighLevelClient.exists(getRequest,RequestOptions.DEFAULT);
	System.out.println(exists);
}

（3）更加id获取文档记录

@Test
public void testGetDocument() throws IOException {
	GetRequest getRequest = new GetRequest("UserName","id");
	GetResponse getResponse = restHighLevelClient.get(getRequest,RequestOptions.DEFAULT);
	System.out.println(getResponse.getSourceAsString()); // 打印文档内容
	System.out.println(getResponse);
}

（4）更新文档记录

@Test
public void testUpdateDocument() throws IOException {
	UpdateRequest request = new UpdateRequest("UserName","id");
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	User user = new User("UserName", age);
	request.doc(JSON.toJSONString(user), XContentType.JSON);
	UpdateResponse updateResponse = restHighLevelClient.update(
	request, RequestOptions.DEFAULT);
	System.out.println(updateResponse.status() == RestStatus.OK);
}

（5）删除文档记录测试

@Test
public void testDelete() throws IOException {
	DeleteRequest request = new DeleteRequest("UserName","id");
	request.timeout(TimeValue.timeValueSeconds(1));
	request.timeout("1s");
	DeleteResponse deleteResponse = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
	System.out.println(deleteResponse.status() == RestStatus.OK);
}

（6）批量添加文档记录测试

@Test
public void testBulkRequest() throws IOException {
	BulkRequest bulkRequest = new BulkRequest();
	bulkRequest.timeout(TimeValue.timeValueMinutes(2));
	bulkRequest.timeout("2m");
	ArrayList<User> userList = new ArrayList<>();
	userList.add(new User("UserName1",3));
	userList.add(new User("UserName2",3));
	userList.add(new User("UserName3",3));
	userList.add(new User("UserOther1",3));
	userList.add(new User("UserOther2",3));
	userList.add(new User("UserOther3",3));
	for (int i =0;i<userList.size();i++){
		bulkRequest.add(new IndexRequest("索引name").id(""+(i+1)).source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
	}
	// bulk
	BulkResponse bulkResponse =
	restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
	System.out.println(!bulkResponse.hasFailures());
}

（7）查询测试

/**
* 使用QueryBuilder
* termQuery("key", obj) 完全匹配
* termsQuery("key", obj1, obj2..) 一次匹配多个值
* matchQuery("key", Obj) 单个匹配, field不支持通配符, 前缀具高级特性
* multiMatchQuery("text", "field1", "field2"..); 匹配多个字段, field有通
*配符忒行
* matchAllQuery(); 匹配所有文件
*SearchSourceBuilder:构建高亮
*
*/
@Test
public void testSearch() throws IOException {
	SearchRequest searchRequest = new SearchRequest("索引名");
	//构建搜索条件
	SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
	//source
	// TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name",
"qinjiang1");
	// sourceBuilder.query(termQueryBuilder);
	//分页
	//sourceBuilder.from()
	// sourceBuilder.size()
	//匹配全部的查询
	MatchAllQueryBuilder matchAllQueryBuilder =QueryBuilders.matchAllQuery();
	sourceBuilder.query(matchAllQueryBuilder);
	sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
	searchRequest.source(sourceBuilder);
	SearchResponse response = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
	System.out.println(JSON.toJSONString(response.getHits()));
	System.out.println("================SearchHit==================");
	for (SearchHit documentFields : response.getHits().getHits()) {
		System.out.println(documentFields.getSourceAsMap());
	}
}

到此，发现了一个规律，它们都遵循RestFul风格的
如：
CreateIndexRequest
DeleteReques
UpdateRequest…
都是**Resuqst的格式