Java集成ElasticSearch及配置类工具类整理
| 前言：做一个有梦想的程序猿！ |
|---|
ES不同的版本API差异比较大，此处ES版本为：6.5.3
代码如下：
添加Maven依赖
<!-- ES -->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.5.3</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>6.5.3</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.5.3</version>
</dependency>
ES配置文件：elasticSearch.properties
host=192.168.43.214
port=9200
schema=http
connectNum=50
connectPerRoute=10
ES配置Bean：ESConfig .java
package com.org.util;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
/**
* 使用javaconfig 配置ES基础配置
* 工厂启动自动创建相关Bean
* @author jqx
*
*/
@Configuration
@ComponentScan(basePackageClasses=EsConfiguration.class)
public class ESConfig {
@Value("${host}")
private String host;
@Value("${port}")
private String port;
@Value("${schema}")
private String schema;
@Value("${connectNum}")
private String connectNum;
@Value("${connectPerRoute}")
private String connectPerRoute;
public ESConfig(){
System.out.println("ESConfig 初始化。。。。。。。。。。");
}
@Bean
public HttpHost httpHost(){
System.out.println("port: "+port+" host:"+host+" schema:"+schema);
return new HttpHost(host,Integer.valueOf(port).intValue(),schema);
}
@Bean(initMethod="init",destroyMethod="close")
public EsConfiguration getFactory(){
return EsConfiguration.build(httpHost(), Integer.valueOf(connectNum), Integer.valueOf(connectPerRoute));
}
/* @Bean
@Scope("singleton")
public RestClient getRestClient(){
return getFactory().getClient();
}*/
@Bean
@Scope("singleton")
public RestHighLevelClient getRHLClient(){
return getFactory().getRhlClient();
}
}
ES连接相关配置类：EsConfiguration.java
package com.org.util;
import java.io.IOException;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
import org.elasticsearch.client.RestClientBuilder.RequestConfigCallback;
import org.elasticsearch.client.RestHighLevelClient;
/**
* ES连接相关配置类
* @author jqx
*
*/
public class EsConfiguration {
public static int CONNECT_TIMEOUT_MILLIS = 1000;
public static int SOCKET_TIMEOUT_MILLIS = 30000;
public static int CONNECTION_REQUEST_TIMEOUT_MILLIS = 500;
public static int MAX_CONN_PER_ROUTE = 10;
public static int MAX_CONN_TOTAL = 30;
private static HttpHost HTTP_HOST;
private RestClientBuilder builder;
//private RestClient restClient;
private RestHighLevelClient restHighLevelClient;
private static EsConfiguration esClientSpringFactory = new EsConfiguration();
private EsConfiguration(){}
public static EsConfiguration build(HttpHost httpHost,Integer maxConnectNum, Integer maxConnectPerRoute){
HTTP_HOST = httpHost;
MAX_CONN_TOTAL = maxConnectNum;
MAX_CONN_PER_ROUTE = maxConnectPerRoute;
return esClientSpringFactory;
}
public static EsConfiguration build(HttpHost httpHost,Integer connectTimeOut, Integer socketTimeOut,
Integer connectionRequestTime,Integer maxConnectNum, Integer maxConnectPerRoute){
HTTP_HOST = httpHost;
CONNECT_TIMEOUT_MILLIS = connectTimeOut;
SOCKET_TIMEOUT_MILLIS = socketTimeOut;
CONNECTION_REQUEST_TIMEOUT_MILLIS = connectionRequestTime;
MAX_CONN_TOTAL = maxConnectNum;
MAX_CONN_PER_ROUTE = maxConnectPerRoute;
return esClientSpringFactory;
}
public void init(){
builder = RestClient.builder(HTTP_HOST);
setConnectTimeOutConfig();
setMutiConnectConfig();
//restClient = builder.build();
restHighLevelClient = new RestHighLevelClient(builder);
System.out.println("init factory");
}
// 配置连接时间延时
public void setConnectTimeOutConfig(){
builder.setRequestConfigCallback(new RequestConfigCallback() {
@Override
public Builder customizeRequestConfig(Builder requestConfigBuilder) {
requestConfigBuilder.setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
requestConfigBuilder.setSocketTimeout(SOCKET_TIMEOUT_MILLIS);
requestConfigBuilder.setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT_MILLIS);
return requestConfigBuilder;
}
});
}
// 使用异步httpclient时设置并发连接数
public void setMutiConnectConfig(){
builder.setHttpClientConfigCallback(new HttpClientConfigCallback() {
@Override
public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
httpClientBuilder.setMaxConnTotal(MAX_CONN_TOTAL);
httpClientBuilder.setMaxConnPerRoute(MAX_CONN_PER_ROUTE);
return httpClientBuilder;
}
});
}
/* public RestClient getClient(){
return restClient;
}*/
public RestHighLevelClient getRhlClient(){
System.out.println("restHighLevelClient: "+restHighLevelClient);
return restHighLevelClient;
}
public void close() {
if (restHighLevelClient != null) {
try {
restHighLevelClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("close client");
}
}
封装Es相关操作工具类：EsSearchSqlUtil.java 基本上包含了ES常用的API
package com.org.util;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
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.get.GetIndexRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
/**
* ES相关操作封装工具类
* @author jqx
*
*/
public class EsSearchSqlUtil {
static Logger logger = Logger.getLogger(EsSearchSqlUtil.class);
@Autowired
private RestHighLevelClient client;
/**
* 创建索引
* @param index
* @return
* @throws IOException
*/
public boolean createIndex(String index) throws IOException {
if (!isIndexExist(index)) {
logger.info("index is not exits!");
}
CreateIndexRequest request = new CreateIndexRequest(index);
request.timeout(TimeValue.timeValueMinutes(2));
request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
request.settings(Settings.builder().put("index.number_of_shards", 5).put("index.number_of_replicas", 1));
//1、同步方法
CreateIndexResponse indexresponse = client.indices().create(request, RequestOptions.DEFAULT);
//2、异步方法不会阻塞并立即返回。
/*ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
@Override
public void onResponse(CreateIndexResponse createIndexResponse) {
//如果执行成功，则调用onResponse方法;
}
@Override
public void onFailure(Exception e) {
//如果失败，则调用onFailure方法。
}
};
client.indices().createAsync(request, RequestOptions.DEFAULT, listener);*/
logger.info("success to create index " + indexresponse.isAcknowledged());
return indexresponse.isAcknowledged();
}
/**
* 删除索引
*
* @param index
* @return
* @throws IOException
*/
public boolean deleteIndex(String index) throws IOException {
if (!isIndexExist(index)) {
logger.info("index is not exits!");
}
DeleteIndexRequest request = new DeleteIndexRequest(index);
request.timeout(TimeValue.timeValueMinutes(2));
request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
//设置IndicesOptions去控制不能用的索引如何解决处理，下面用lenientExpandOpen进行通用的处理
request.indicesOptions(IndicesOptions.lenientExpandOpen());
//1、同步方法
AcknowledgedResponse dResponse = client.indices().delete(request,RequestOptions.DEFAULT);
//2、异步方法不会阻塞并立即返回。
/*ActionListener<AcknowledgedResponse> listener = new ActionListener<AcknowledgedResponse>() {
@Override
public void onFailure(Exception arg0) {
// TODO Auto-generated method stub
}
@Override
public void onResponse(AcknowledgedResponse arg0) {
// TODO Auto-generated method stub
}
};
client.indices().deleteAsync(request, RequestOptions.DEFAULT, listener);*/
if (dResponse.isAcknowledged()) {
logger.info("delete index " + index + " successfully!");
} else {
logger.info("fail to delete index " + index);
}
return dResponse.isAcknowledged();
}
/**
* 判断索引是否存在
*
* @param index
* @return
* @throws IOException
*/
public boolean isIndexExist(String index) throws IOException {
GetIndexRequest request = new GetIndexRequest();
request.indices(index);
request.local(false);
request.humanReadable(true);
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
if (exists) {
logger.info("index [" + index + "] is exist!");
} else {
logger.info("index [" + index + "] is not exist!");
}
return exists;
}
/**
* 通过ID获取数据
*
* @param index 索引，类似数据库
* @param type 类型，类似表
* @param id 数据ID
* @param includFields 需要显示的字段，逗号分隔（缺省为全部字段）
* @return
* @throws IOException
*/
public Map<String, Object> searchDataById(String index, String type, String id, String includFields) throws IOException {
GetRequest request = new GetRequest(index,type, id);
if (StringUtils.isNotEmpty(includFields)) {
//不展示的字段
String[] excludeFields = new String[]{};
//查询特定字段,包含和不包含的字段
FetchSourceContext fetchSourceContext =new FetchSourceContext(true, includFields.split(","),excludeFields );
request.fetchSourceContext(fetchSourceContext);
//为特定的存储字段配置检索(要求字段在映射中单独存储)
//request.storedFields(storeFields);
}
GetResponse response = client.get(request, RequestOptions.DEFAULT);
return response.getSource();
}
/**
* 使用分词查询
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param matchStr 过滤条件（xxx=111,aaa=222）
* @return
* @throws IOException
*/
public List<Map<String, Object>> searchListData(String index, String type, String fields, String matchStr) throws IOException {
return searchListData(index, type, 0, 0, null, fields, null, false, null, matchStr);
}
/**
* 使用分词查询
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param matchPhrase true 使用，短语精准匹配
* @param matchStr 过滤条件（xxx=111,aaa=222）
* @return
* @throws IOException
*/
public List<Map<String, Object>> searchListData(String index, String type, String fields, String sortField, boolean matchPhrase, String matchStr) throws IOException {
return searchListData(index, type, 0, 0, null, fields, sortField, matchPhrase, null, matchStr);
}
/**
* 使用分词查询
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param size 文档大小限制
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param matchPhrase true 使用，短语精准匹配
* @param highlightField 高亮字段
* @param matchStr 过滤条件（xxx=111,aaa=222）
* @return
* @throws IOException
*/
public List<Map<String, Object>> searchListData(String index, String type, Integer size, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) throws IOException {
return searchListData(index, type, 0, 0, size, fields, sortField, matchPhrase, highlightField, matchStr);
}
/**
* 使用分词查询
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param startTime 开始时间
* @param endTime 结束时间
* @param size 文档大小限制
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param matchPhrase true 使用，短语精准匹配
* @param highlightField 高亮字段
* @param matchStr 过滤条件（xxx=111,aaa=222）
* @return
* @throws IOException
*/
public List<Map<String, Object>> searchListData(String index, String type, long startTime, long endTime, Integer size, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) throws IOException {
SearchRequest request = new SearchRequest (index);
SearchSourceBuilder searchRequestBuilder = new SearchSourceBuilder();
if (StringUtils.isNotEmpty(type)) {
request.types(type.split(","));
}
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
if (startTime > 0 && endTime > 0) {
boolQuery.must(QueryBuilders.rangeQuery("processTime")
.format("epoch_millis")
.from(startTime)
.to(endTime)
.includeLower(true)
.includeUpper(true));
}
//搜索的的字段
if (StringUtils.isNotEmpty(matchStr)) {
for (String s : matchStr.split(",")) {
String[] ss = s.split("=");
if (ss.length > 1) {
if (matchPhrase == Boolean.TRUE) {
boolQuery.must(QueryBuilders.matchPhraseQuery(s.split("=")[0], s.split("=")[1]));
} else {
boolQuery.must(QueryBuilders.matchQuery(s.split("=")[0], s.split("=")[1]));
}
}
}
}
// 高亮（xxx=111,aaa=222）
if (StringUtils.isNotEmpty(highlightField)) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
//highlightBuilder.preTags("<span style='color:red' >");//设置前缀
//highlightBuilder.postTags("</span>");//设置后缀
// 设置高亮字段
highlightBuilder.field(highlightField);
searchRequestBuilder.highlighter(highlightBuilder);
}
searchRequestBuilder.query(boolQuery);
if (StringUtils.isNotEmpty(fields)) {
searchRequestBuilder.fetchSource(fields.split(","), null);
}
searchRequestBuilder.fetchSource(true);
if (StringUtils.isNotEmpty(sortField)) {
searchRequestBuilder.sort(sortField, SortOrder.DESC);
}
if (size != null && size > 0) {
searchRequestBuilder.size(size);
}
request.source(searchRequestBuilder);
SearchResponse searchResponse = client.search(request, RequestOptions.DEFAULT);
long totalHits = searchResponse.getHits().totalHits;
long length = searchResponse.getHits().getHits().length;
System.out.println("totalHits: "+totalHits+" length: "+length);
if (searchResponse.status().getStatus() == 200) {
// 解析对象
return setSearchResponse(searchResponse, highlightField);
}
return null;
}
/**
* 使用分词查询,并分页
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param currentPage 当前页
* @param pageSize 每页显示条数
* @param startTime 开始时间
* @param endTime 结束时间
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param matchPhrase true 使用，短语精准匹配
* @param highlightField 高亮字段
* @param matchStr 过滤条件（xxx=111,aaa=222）
* @return
* @throws IOException
*/
public EsDataPage searchDataPage(String index, String type, int currentPage, int pageSize, long startTime, long endTime, String fields, String sortField, boolean matchPhrase, String highlightField, String matchStr) throws IOException {
//SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
SearchRequest request = new SearchRequest (index);
SearchSourceBuilder searchRequestBuilder = new SearchSourceBuilder();
if (StringUtils.isNotEmpty(type)) {
request.types(type.split(","));
}
request.searchType(SearchType.QUERY_THEN_FETCH);
// 需要显示的字段，逗号分隔（缺省为全部字段）
if (StringUtils.isNotEmpty(fields)) {
searchRequestBuilder.fetchSource(fields.split(","), null);
}
//排序字段
if (StringUtils.isNotEmpty(sortField)) {
searchRequestBuilder.sort(sortField, SortOrder.DESC);
}
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
if (startTime > 0 && endTime > 0) {
boolQuery.must(QueryBuilders.rangeQuery("@timestamp")
.format("epoch_millis")
.from(startTime)
.to(endTime)
.includeLower(true)
.includeUpper(true));
}
// 查询字段
if (StringUtils.isNotEmpty(matchStr)) {
for (String s : matchStr.split(",")) {
String[] ss = s.split("=");
if (ss.length > 1) {
if (matchPhrase == Boolean.TRUE) {
boolQuery.must(QueryBuilders.matchPhraseQuery(s.split("=")[0], s.split("=")[1]));
} else {
boolQuery.must(QueryBuilders.matchQuery(s.split("=")[0], s.split("=")[1]));
}
}
}
}
// 高亮（xxx=111,aaa=222）
if (StringUtils.isNotEmpty(highlightField)) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
//highlightBuilder.preTags("<span style='color:red' >");//设置前缀
//highlightBuilder.postTags("</span>");//设置后缀
// 设置高亮字段
highlightBuilder.field(highlightField);
searchRequestBuilder.highlighter(highlightBuilder);
}
searchRequestBuilder.query(QueryBuilders.matchAllQuery());
searchRequestBuilder.query(boolQuery);
// 分页应用
searchRequestBuilder.from(currentPage).size(pageSize);
// 设置是否按查询匹配度排序
searchRequestBuilder.explain(true);
//打印的内容 可以在 Elasticsearch head 和 Kibana 上执行查询
// logger.info("\n{}", searchRequestBuilder);
// 执行搜索,返回搜索响应信息
request.source(searchRequestBuilder);
SearchResponse searchResponse = client.search(request, RequestOptions.DEFAULT);
long totalHits = searchResponse.getHits().totalHits;
long length = searchResponse.getHits().getHits().length;
// logger.debug("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);
if (searchResponse.status().getStatus() == 200) {
// 解析对象
List<Map<String, Object>> sourceList = setSearchResponse(searchResponse, highlightField);
return new EsDataPage(currentPage, pageSize, (int) totalHits, sourceList);
}
return null;
}
/**
* 高亮结果集 特殊处理
*
* @param searchResponse
* @param highlightField
*/
private List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
List<Map<String, Object>> sourceList = new ArrayList<Map<String, Object>>();
StringBuffer stringBuffer = new StringBuffer();
for (SearchHit searchHit : searchResponse.getHits().getHits()) {
searchHit.getSourceAsMap().put("id", searchHit.getId());
if (StringUtils.isNotEmpty(highlightField)) {
System.out.println("遍历 高亮结果集，覆盖 正常结果集" + searchHit.getSourceAsMap());
Text[] text = searchHit.getHighlightFields().get(highlightField).getFragments();
if (text != null) {
for (Text str : text) {
stringBuffer.append(str.string());
}
//遍历 高亮结果集，覆盖 正常结果集
searchHit.getSourceAsMap().put(highlightField, stringBuffer.toString());
}
}
sourceList.add(searchHit.getSourceAsMap());
}
return sourceList;
}
}
**Es查询分页工具类：EsDataPage.java **
package com.org.util;
import java.util.List;
import java.util.Map;
/**
* ES分页数据实体封装
* @author jqx
*
*/
public class EsDataPage {
private Integer currentPage;
private Integer pageSize;
private Integer totalHits;
private List<Map<String,Object>> sourceList;
public EsDataPage(){
}
//有参构造
public EsDataPage(Integer currentPage,Integer pageSize,Integer totalHits,List<Map<String,Object>> sourceList){
this.currentPage = currentPage;
this.pageSize = pageSize;
this.totalHits = totalHits;
this.sourceList = sourceList;
}
public Integer getCurrentPage() {
return currentPage;
}
public void setCurrentPage(Integer currentPage) {
this.currentPage = currentPage;
}
public Integer getPageSize() {
return pageSize;
}
public void setPageSize(Integer pageSize) {
this.pageSize = pageSize;
}
public Integer getTotalHits() {
return totalHits;
}
public void setTotalHits(Integer totalHits) {
this.totalHits = totalHits;
}
public List<Map<String, Object>> getSourceList() {
return sourceList;
}
public void setSourceList(List<Map<String, Object>> sourceList) {
this.sourceList = sourceList;
}
}
最后，Es测试类：EsTest.java
package com.org.test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.alibaba.fastjson.JSON;
import com.org.mapper.User;
import com.org.mapper.UserMapper;
import com.org.service.EsSearchOperateService;
import com.org.util.EsDataPage;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-mybatis.xml")
public class EsTest{
private String index; //es索引
private String type; //es类型
@Autowired
private RestHighLevelClient restHighLevelClient;
@Autowired
private UserMapper userMapper;
@Autowired
private EsSearchOperateService esSearchOperateService;
@Before
public void prepare() {
index = "index1";
type = "user";
}
/**
* 添加数据
*/
@Test
public void addTest() {
IndexRequest indexRequest = new IndexRequest(index, type);
//User user = userMapper.selectById(1l);
/* List<User> list = userMapper.selectList();
for (User uu : list) {
String source = JSON.toJSONString(uu);
indexRequest.source(source, XContentType.JSON);
try {
IndexResponse response = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
System.out.println("--STATUS--:"+response.status());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}*/
}
/**
* id存在则更新，id不存在则创建
*/
@Test
public void updateTest(){
UpdateRequest updateRequest = new UpdateRequest(index, type, "akt0cW0BTxiEHOu6eJAf");
User user=new User();
user.setAddress("近年来,随着互联网行业的蓬勃发展,信息量呈指数增长,一个好的搜索引擎就显得极为必要,为了解决当前在大数据时代面临的信息爆炸的问题。本系统用ElasticSearch设计并实现了个人搜索引擎,开发技术主要使用轻量级框架Django技术、MySQL,搜索框架采用ElasticSearch实现网页数据的获取,搜索建议的生成,数据的存储,以及数据搜索后的展示。");
user.setId(10l);
user.setPassward("134532");
user.setPhone("18765745890");
String source = JSON.toJSONString(user);
updateRequest.doc(source,XContentType.JSON).upsert(source, XContentType.JSON);
try {
UpdateResponse response = restHighLevelClient.update(updateRequest,RequestOptions.DEFAULT);
System.out.println("--STATUS--:"+response.status());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 删除
*/
@Test
public void deleteTest(){
DeleteRequest deleteRequest = new DeleteRequest(index, type, "mlZOa20BLcVy-BTtAtnK");
try {
DeleteResponse response = restHighLevelClient.delete(deleteRequest,RequestOptions.DEFAULT);
System.out.println("--STATUS--:"+response.status());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 批量添加数据
*/
@Test
public void batchAddTest() {
BulkRequest bulkRequest = new BulkRequest();
List<IndexRequest> requests = generateRequests();
for (IndexRequest indexRequest : requests) {
bulkRequest.add(indexRequest);
}
try {
restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public List<IndexRequest> generateRequests(){
List<IndexRequest> requests = new ArrayList<>();
requests.add(generateNewsRequest(7l,"187364758675", "一天", "ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。ElasticSearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示，Elasticsearch是最受欢迎的企业搜索引擎，其次是Apache Solr，也是基于Lucene。","ggsf"));
requests.add(generateNewsRequest(8l,"18767856783", "小红", "ElasticSearch 是一个分布式、高扩展、高实时的搜索与数据分析引擎。它能很方便的使大量数据具有搜索、分析和探索的能力。充分利用ElasticSearch的水平伸缩性，能使数据在生产环境变得更有价值。ElasticSearch 的实现原理主要分为以下几个步骤，首先用户将数据提交到Elastic Search 数据库中，再通过分词控制器去将对应的语句分词，将其权重和分词结果一并存入数据，当用户搜索数据时候，再根据权重将结果排名，打分，再将返回结果呈现给用户。","ggsf"));
requests.add(generateNewsRequest(9l,"187364775475", "张三", "Elasticsearch是与名为Logstash的数据收集和日志解析引擎以及名为Kibana的分析和可视化平台一起开发的。这三个产品被设计成一个集成解决方案，称为“Elastic Stack”（以前称为“ELK stack”）。","ggsf"));
requests.add(generateNewsRequest(10l,"187360095375", "李四", "Elasticsearch可以用于搜索各种文档。它提供可扩展的搜索，具有接近实时的搜索，并支持多租户。”Elasticsearch是分布式的，这意味着索引可以被分成分片，每个分片可以有0个或多个副本。每个节点托管一个或多个分片，并充当协调器将操作委托给正确的分片。再平衡和路由是自动完成的。“相关数据通常存储在同一个索引中，该索引由一个或多个主分片和零个或多个复制分片组成。一旦创建了索引，就不能更改主分片的数量。","ggsf"));
requests.add(generateNewsRequest(7l,"187364758675", "小花", "Elasticsearch使用Lucene，并试图通过JSON和Java API提供其所有特性。它支持facetting和percolating，如果新文档与注册查询匹配，这对于通知非常有用。另一个特性称为“网关”，处理索引的长期持久性；例如，在服务器崩溃的情况下，可以从网关恢复索引。Elasticsearch支持实时GET请求，适合作为NoSQL数据存储，但缺少分布式事务。","ggsf"));
return requests;
}
public IndexRequest generateNewsRequest(Long id, String phone, String name,String address,String passward ){
IndexRequest indexRequest = new IndexRequest(index, type);
User user=new User();
user.setAddress(address);
//user.setId(id);
user.setName(name);
user.setPassward(passward);
user.setPhone(phone);
String source = JSON.toJSONString(user);
indexRequest.source(source, XContentType.JSON);
return indexRequest;
}
/**
* 根据id查询ES数据
*/
@Test
public void getByIdTest(){
try {
Map<String,Object> map = esSearchOperateService.searchDataById(index, type, "n1ZYa20BLcVy-BTtmdmU", "name,address,passward,phone");
System.out.println(map.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 分词查询ES数据
*/
@Test
public void getList1Test(){
try {
List<Map<String, Object>> list=esSearchOperateService.searchListData(index, type, "name,address,passward,phone", "address=万达,address=中原");
list.forEach(str-> System.out.println(str));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 分词查询ES数据
*/
@Test
public void getList2Test(){
try {
List<Map<String, Object>> list = esSearchOperateService.searchListData(index, type, 0l, 0l, 500, "name,address,passward,phone", "phone.keyword", true, "name", "address=中原");
list.forEach(str-> System.out.println(str));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 分词查询ES数据-分页(from-size-适用冷词分页)-高亮关键词
*/
@Test
public void getList3Test(){
try {
int currentPage = 1;
int pageSize = 10;
EsDataPage dataPage = esSearchOperateService.searchDataPage(index, type, currentPage, pageSize, 0l, 0l, "name,address,passward,phone", "phone.keyword", true, "name", "address=中原");
dataPage.getSourceList().forEach(str-> System.out.println(str));
System.out.println("总数据量： "+dataPage.getTotalHits());
System.out.println("当前命中数： "+dataPage.getSourceList().size());
System.out.println("当前页： "+dataPage.getCurrentPage());
System.out.println("每页数据行数： "+dataPage.getPageSize());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 分词查询ES数据-分页(scroll-适用热词分页)-高亮关键词
*/
@Test
public void getList4Test(){
try {
int currentPage = 1;
int pageSize = 4;
EsDataPage dataPage = esSearchOperateService.searchScrollDataPage(index, type, currentPage, pageSize, 0l, 0l, "name,address,passward,phone", "phone.keyword", true, "address", "address=elasticsearch");
dataPage.getSourceList().forEach(str-> System.out.println(str));
System.out.println("总数据量： "+dataPage.getTotalHits());
System.out.println("当前命中数： "+dataPage.getSourceList().size());
System.out.println("当前页： "+dataPage.getCurrentPage());
System.out.println("每页数据行数： "+dataPage.getPageSize());
} catch (IOException e) {
e.printStackTrace();
}
}
}
最后，如果本篇文章对您有所帮助，可以评论或点赞支持一下哦，感谢感谢！
1552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
