springboot2.0 集成elasticsearch，实现检索、分页、排序

<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.5.1</version>
</dependency> <!--如果不指定，springboot会自动引入5.x版本,所以需要强行引入高版本，
elasticsearch-rest-client版本是同步，不需要强行指定，如果发现不同步也可以指定-->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.5.1</version>
</dependency>

可以配置多个数据节点
elasticsearch:
ip: 192.168.31.10:9200,192.168.1.101:9200

@Configuration
public class ESConfig {
private Logger logger = LoggerFactory.getLogger(ESConfig.class);
private static final int ADDRESS_LENGTH = 2;
private static final String HTTP_SCHEME = "http"; /**
* 使用冒号隔开ip和端口
*/
@Value("${elasticsearch.ip}")
String[] ipAddress; @Bean
public RestClientBuilder restClientBuilder() {
HttpHost[] hosts = Arrays.stream(ipAddress)
.map(this::makeHttpHost)
.filter(Objects::nonNull)
.toArray(HttpHost[]::new);
logger.info("ES hosts:{}", Arrays.toString(hosts));
return RestClient.builder(hosts);
}

//low-level
@Bean
public RestClient restClient(){
return restClientBuilder().build();
}
//high-level
@Bean(name = "highLevelClient")
public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
restClientBuilder.setMaxRetryTimeoutMillis(60000);
return new RestHighLevelClient(restClientBuilder);
} private HttpHost makeHttpHost(String s) {
String[] address = s.split(":");
if (address.length == ADDRESS_LENGTH) {
String ip = address[0];
int port = Integer.parseInt(address[1]);
return new HttpHost(ip, port, HTTP_SCHEME);
} else {
return null;
}
}
}

@Service
public class ESIndexServiceImpl implements ESIndexService { @Resource
RestClient restClient; @Override
public List<ESIndexObject> getAllESIndex() {
return getESIndexByName("");
} private <T> List<T> getDataByQuery(String method,String query)
{
Request request = new Request(method.toUpperCase(),query);
try {
Response response = restClient.performRequest(request);
RequestLine requestLine = response.getRequestLine();
HttpHost host = response.getHost();
int statusCode = response.getStatusLine().getStatusCode();
Header[] headers = response.getHeaders();
System.out.println(requestLine);
System.out.println(host);
System.out.println(statusCode);
System.out.println(headers);
String responseBody = EntityUtils.toString(response.getEntity());
ObjectMapper mapper = new ObjectMapper(); List<T> list = mapper.readValue(responseBody,new TypeReference<List<T>>(){}); return list;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

//获取指定或者所有索引
//cat api不支持分页，所以数据返回后在client分页，做在前端，数据量也不大
@Override
public List<ESIndexObject> getESIndexByName(String index) {
if(index==null) index = "";
String strQuery = "/_cat/indices/*"+index+"*?v&h=uuid,health,status,index,docsCount,storeSize,cds&s=cds:desc&format=json";
List<ESIndexObject> list = getDataByQuery("GET",strQuery);
return list;
}
}

//实体和response返回字段一致，可以用反序列化直接生成对象
public class ESIndexObject implements Serializable {
private String uuid;
private String index;
private String health;
private String status;
private int docsCount;
private String storeSize;
private String cds; //creation.date.string 。。。省略getter,setter
}

PUT customer
{
"settings": {
"number_of_replicas": 0,
"number_of_shards": 1,
"index":{
"analysis.analyzer.default.type":"ik_max_word",
"analysis.search_analyzer.default.type":"ik_smart"
}
},
"mappings": {
"doc":{
"properties":{ }
}
}
}
类似这样，多弄几个数据
POST /customer/doc/510228192101063619
{
"name":"燕子李三",
"id":"510228192101063619",
"addr":"天津市前卫营850号",
"tel":"13700102347"
}

public class ESCustomer implements Serializable {
private long id;
private String name;
private String addr;
private String tel; ...省略getter,setter
}

@Service
public class ESCustomerServiceImpl implements ESCustomerService {
@Resource
RestClient restClient; @Resource(name = "highLevelClient")
RestHighLevelClient restHighLevelClient; private ObjectMapper mapper = new ObjectMapper(); private String indexName = "customer"; //包装SearchResponse返回数据到List
private <T> List<T> wrapperData(SearchResponse response) throws Exception {
SearchHits hits = response.getHits();
long totalHits = hits.getTotalHits();
System.out.println("Customer search totalHits:" + totalHits);
List<T> list = new ArrayList<>();
SearchHit[] searchHits = hits.getHits();
//SearchHits实现了Iterable接口，可以直接进行迭代
//根据测试这里可以用hits变量替换searchHits变量
for (SearchHit hit : searchHits) {
String index = hit.getIndex(); //获取文档的index
String type = hit.getType(); //获取文档的type
String id = hit.getId(); //获取文档的id
Map<String, Object> sourceMap = hit.getSourceAsMap(); //获取文档内容，封装为map
System.out.println("index:" + index + ",type:" + type + ",id:" + id + ",\nsource:" + sourceMap);
String sourceString = hit.getSourceAsString(); //获取文档内容，转换为json字符串。
T object = mapper.readValue(sourceString, new TypeReference<T>() {
});
list.add(object);
}
return list;
} //包装SearchSourceBuilder，用pageable完成分页和排序的设置
//排序字段必须建立keyword字段
private SearchSourceBuilder wrapperBuilder(SearchSourceBuilder builder, Pageable pageable) {
builder.from(pageable.getPageNumber() * pageable.getPageSize());
builder.size(pageable.getPageSize());
Sort sort = pageable.getSort();
Iterator iterator = sort.iterator();
while (iterator.hasNext()) {
Sort.Order order = (Sort.Order) iterator.next();
//用keyword字段来排序，所以在建立索引的时候，就必须同步建立keyword字段
builder.sort(order.getProperty() + ".keyword", order.getDirection() == Sort.Direction.ASC ? SortOrder.ASC : SortOrder.DESC);
}
return builder;
} @Override
public Page<ESCustomer> searchAllInPage(Pageable pageable) {
return searchAllByAllField("",pageable);
} //后期代码需重构，通过反射获取字段，然后构建数组来实现
//query有值就按按值做全字段全文检索，对于类似身份证和电话等字段采用通配wildcard检索方式，query无值则返回所有数据
//按Pageable分页和排序，暂时只能排序一个字段
@Override
public Page<ESCustomer> searchAllByAllField(String query, Pageable pageable) {
SearchRequest searchRequest = new SearchRequest(this.indexName);
SearchSourceBuilder builder = wrapperBuilder(new SearchSourceBuilder(),pageable);
if(query==null||query=="")
{
builder.query(QueryBuilders.matchAllQuery());
}else {
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
.should(QueryBuilders.matchQuery("name",query))
.should(QueryBuilders.matchQuery("addr",query))
.should(QueryBuilders.wildcardQuery("tel","*"+query+"*"))
.should(QueryBuilders.wildcardQuery("id","*"+query+"*"));
builder.query(boolQueryBuilder);
}
searchRequest.source(builder);
try {
SearchResponse searchResponse = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
List<ESCustomer> esCustomerList = wrapperData(searchResponse);
Page<ESCustomer> esCustomerPage = new PageImpl<>(esCustomerList, pageable,
searchResponse.getHits().getTotalHits());
return esCustomerPage;
}catch (Exception e)
{
e.printStackTrace();
return null;
}
} @Override
public List<ESCustomer> searchAll() {
SearchRequest searchRequest = new SearchRequest(indexName);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchRequest.source(searchSourceBuilder);
try {
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT); List<ESCustomer> esCustomerList = wrapperData(searchResponse);
return esCustomerList; } catch (Exception e) {
e.printStackTrace();
return null;
}
} // 使用low-level方式实现检索
// 需要自己实现返回的json数据封装，演示，暂时未实现
@Deprecated
public List<ESCustomer> searchByNameByRaw(String name) {
String query = "{\n" +
" \"query\": {\n" +
" \"match\": {\n" +
" \"name\": {\n" +
" \"query\": \"" + name + "\"\n" +
" , \"analyzer\": \"ik_smart\"\n" +
" }\n" +
" }\n" +
" },\n" +
" \"highlight\": {\n" +
" \"fields\": {\"name\": {}}\n" +
" }\n" +
"}";
Request request = new Request("GET", "/user*/_search");
HttpEntity httpEntity = new NStringEntity(query, ContentType.APPLICATION_JSON);
request.setEntity(httpEntity); try {
Response response = restClient.performRequest(request);
String responseBody = EntityUtils.toString(response.getEntity());
System.out.println(response);
System.out.println(responseBody);
JSONObject jsonObject = JSON.parseObject(responseBody);
Object hits = jsonObject.get("hits");
System.out.println(hits);
ObjectMapper mapper = new ObjectMapper();
Map mapResponseBody = mapper.readValue(responseBody, Map.class);
Object source = mapResponseBody.get("hits");
System.out.println(source);
// List<ESCustomer> list = mapper.readValue(responseBody,new TypeReference<List<ESCustomer>>(){});// return list;
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}

@Controller
@RequestMapping("/esCustomer")
public class ESCustomerController {
@Resource
ESCustomerService esCustomerService; @RequestMapping("/list")
public String list() {
return "/ESCustomer/customerList";
} @RequestMapping("/getList")
@ResponseBody
public Object getESCustomerList(HttpServletRequest request) { Pageable pageable = ControllerUtils.getPageInfo(request);
String searchText = ControllerUtils.getSearchText(request);
Page<ESCustomer> page = esCustomerService.searchAllByAllField(searchText,pageable); Map<String, Object> map = new HashMap<>();
map.put("total", page.getTotalElements());
map.put("rows", page.getContent()); return map;
}
}