ElaticSearch介绍
一个实时的分布式搜索和分析引擎。设计用于云计算,能够达到实时搜索,稳定,可靠,快速,方便安装,且基于restful接口。
ElaticSearch与数据库的比较
Database(数据库) | Index(索引库) |
Table(表) | Type(类型) |
Row(行) | document(文档) |
Col(列) | filed(字段) |
安装(windows的环境安装ElasticSearch6.7版本)PS->linux下的安装类似
1、下载ElasticSearch压缩包,然后解压
2、修改config下的elasticsearch.yml文件
- 设置node.name
- 设置cluster.name
- 设置 network.host
3、点击bin目录下的elasticsearch.bat进行启动。
4、测试,浏览器输入地址:http://192.168.5.61:9200/,如果打印如下结果,那么安装成功
5、安装kibana-6.7.2可视化插件,下载好kibana-6.7.2,然后在config下的kibana.yml文件做如下修改:
server.port: 5601
server.host: "192.168.5.61"
elasticsearch.hosts: ["http://192.168.5.61:9200"]
6、测试插件,在本地浏览器中输入http://192.168.5.61:5601,如果看到以下截图,说明插件安装成功
7、将ElasticSearch 安装成Windows服务(Service),切换到ElasticSearch的bin目录,执行service.bat install
8、启动ElasticSearch服务 service.bat start
9、在run界面,输入 services.msc,查看ElasticSearch服务
常用命令(如果需要测试如下命令,可以在dos窗口和kibana可视化插件进行测试,由于dos窗口每次对elasticsearch操作的时候,需要输入ip和端口,如:http://192.168.5.61:9200/_cat/health?v,然而在插件进行操作的时候,不需要输入ip和端口,因为这些都在配置文件配置好了。因此建议在插件进行操作,截图如下:
1、查看健康状态
get /_cat/health?v
2、创建索引
Put 索引名称
3、插入数据
格式如下:
PUT /index_name/type_name/doc_id
{
"key1": "value1", "key2": "value2", "key3": "value3" ......
}
案例如下:
put /mytest/user/1
{
"name":"zhangsan",
"age":"24"
}
备注:mytest是索引名称,user是类型名称,1是id
不指定文档id上传,系统会生成一个唯一的文档id如:
put /mytest/user
{
"name":"zhangsan",
"age":"24"
}
4、修改文档
文档在ElasticSearch中是不可变,修改文档的逻辑是新建一个文档覆盖旧文档。
PUT /index_name/type_name/doc_id
{
"key11": "value11",
"key22": "value22",
"key33": "value33"
}
响应中_version字段会加一。
5、删除文档
DELETE /index_name/type_name/doc_id
6、删除索引
DELETE /index_name
7、删除多个索引
DELETE /index_name1, index_name2
8、删除所有的索引
DELETE /_all
9、修改索引设置
PUT /index_name/_setting
{
"number_of_replicas": 1
}
修改index_name的索引,设置备份分片为1
10、打开或关闭索引
POST /index_name/_close
{
}
关闭索引,搜索时只能显示元数据不能显示具体的数据
POST /index_name/_open
{
}
开启索引,可以搜索的具体的数据
11、空搜索
GET /_search
没有指定任何查询条件,只返回索引中的所有文档
12、多索引搜索
GET /index_1,index_2/_search
在index index_1和index_2中搜索
GET /index_name/type_name/doc_id/_source
只获取指定id的source内容,会忽略元信息
GET /index_1,index_2/type_1,type_2/_search
在indexindex_1和index_2中搜索类型type_1和type_2
13、分页
GET /_search?size=5&from=5
使用size和from进行分页
14、条件搜索
GET /_all/index_name/_search?q=filed_name:field_value
搜索所有索引中类型为index_name索引中filed_name中包含filed_value的文档。
注意: 1、索引库得名称必须全部小写,不能以下划线开头,也不能包含逗号。
2、7.0之前默认会创建5个shared,7.0开始之后创建一个shard。
3、再ES6.0之后,一个index对应一个type。
健康状态值
Green(代表正常)
Yellow(代表正常,但是一些副本还没有分配)
Red(非正常)
Java客户端连接ES
Java客户端连接ES主要两种实现方式,Elasticsearch(ES)有两种连接方式:transport、rest。transport通过TCP方式访问ES(只支持java),rest方式通过http API 访问ES(没有语言限制)。
TransportClient
步骤1:获取client;
步骤2:执行对应的增、删、改、查操作。
查询使用参考(以下我已经验证过,好用ok):
/**
* Query Search
* @param index
* @param type
* @param term
* @param queryString
*/
private static void querySearch(String index, String type,String term,String queryString){
Client client = createTransportClient();
SearchResponse response = client.prepareSearch(index)
.setTypes(type)
// 设置查询类型
// 1.SearchType.DFS_QUERY_THEN_FETCH = 精确查询
// 2.SearchType.SCAN = 扫描查询,无序
// 3.SearchType.COUNT = 不设置的话,这个为默认值,还有的自己去试试吧
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
// 设置查询关键词
.setQuery(QueryBuilders.matchQuery(term, queryString))
.addHighlightedField(term)
.setHighlighterPreTags("<em>")
.setHighlighterPostTags("</em>")
// 设置查询数据的位置,分页用
.setFrom(0)
// 设置查询结果集的最大条数
.setSize(60)
// 设置是否按查询匹配度排序
.setExplain(true)
// 最后就是返回搜索响应信息
.execute()
.actionGet();
SearchHits searchHits = response.getHits();
System.out.println("-----------------在["+term+"]中搜索关键字["+queryString+"]---------------------");
System.out.println("共匹配到:"+searchHits.getTotalHits()+"条记录!");
SearchHit[] hits = searchHits.getHits();
for (SearchHit searchHit : hits) {
//获取高亮的字段
Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
HighlightField highlightField = highlightFields.get(term);
System.out.println("高亮字段:"+highlightField.getName()+"\n高亮部分内容:"+highlightField.getFragments()[0].string());
Map<String, Object> sourceAsMap = searchHit.sourceAsMap();
Set<String> keySet = sourceAsMap.keySet();
for (String string : keySet) {
//key value 值对应关系
System.out.println(string+":"+sourceAsMap.get(string));
}
System.out.println();
}
}
Rest
官方提供low-level rest client(支持5.0及以后版本) 和high-level rest client(支持版本为 5.6及以后版本)
引入maven依赖
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-client</artifactId>
<version>6.5.4</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>rest</artifactId>
<version>5.3.2</version>
</dependency>
创建rest client
Header[] defaultHeaders = new Header[] { new BasicHeader("header", "value") };
RestClient restClient = RestClient.builder(
new HttpHost("localhost", 9200, "http"))
.setDefaultHeaders(defaultHeaders) //设置默认标头
.setMaxRetryTimeoutMillis(10000) //同一请求重试超时时间,默认30s
.setFailureListener(new RestClient.FailureListener() {
}) //设置侦听器,节点出现故障会收到通知
.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
@Override
public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
//create the authentication scope
AuthScope authScope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope
.ANY_REALM);
// Create credential pair(username,password)
UsernamePasswordCredentials usernamePasswordCredentials = new UsernamePasswordCredentials("username", "password");
credentialsProvider.setCredentials(authScope, usernamePasswordCredentials);
return httpClientBuilder.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
@Override
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
return 30 * 1000;
}
}).setDefaultCredentialsProvider(credentialsProvider);
}
})
.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
@Override
public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
return requestConfigBuilder.setSocketTimeout(10000);
}
})
.build();
引入maven依赖
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.7.1</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.7.2</version>
</dependency>
创建rest client
RestHighLevelClient client = new RestHighLevelClient( RestClient.builder(new HttpHost("localhost", 9200, "http")));
由于在阿里云使用的是ES6.7,仅支持high level rest client,因此在后面着重对该模式进行阐述。
常用的操作工具类:ElasticSearchUtils.java
package com.dflm.weixin.elasticsearch;
import com.dflm.weixin.business.exception.BusinessException;
import com.dflm.weixin.business.model.User;
import com.dflm.weixin.util.ValidateUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.entity.ContentType;
import org.apache.http.nio.entity.NStringEntity;
import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.*;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.IndicesClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import java.io.IOException;
import java.util.*;
/**
* <p>
* 在该项目中,使用的ElaticSearch的版本为6.7,因此只允许一个index下对应一个type,
* 不能出现多个type
* </p>
* ElasticSearch操作工具类
* @author lh
* @version 1.0
* @time 2019-05-15
*/
public class ElasticSearchUtils {
// 引入logger日志对象
public static final Log logger = LogFactory.getLog(ElasticSearchUtils.class);
// 初始化API客户端
public static RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("192.168.5.61", 9200, "http")
));
/**
* 关键字搜索->指定匹配类型
* @param indexName 索引名称
* @param type 类型
* @param fieldName 字段名称
* @param keyword 关键词
* @param start 开始下标
* @param count 总的记录数
* @return
* @throws IOException
*/
public static List<Map<String, Object>> search(String indexName,String type, String fieldName, String keyword, int start, int count) throws IOException {
// 初始化搜索请求对象,构造注入索引名
SearchRequest searchRequest = new SearchRequest(indexName);
// 初始化SearchSourceBuilder对象
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
// 关键字匹配对应字段
MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder(fieldName, keyword);
// 模糊匹配
matchQueryBuilder.fuzziness(Fuzziness.AUTO);
sourceBuilder.query(matchQueryBuilder);
// 第start页
sourceBuilder.from(start);
// 共count条
sourceBuilder.size(count);
searchRequest.source(sourceBuilder);
searchRequest.types(type);
// 匹配度从高到低
sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
// 获取搜索返回对象
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
// 获取搜索击中对象
SearchHits hits = searchResponse.getHits();
List<Map<String, Object>> matchRsult = new LinkedList<>();
// 将击中的数据放入到集合
for (SearchHit hit : hits.getHits()) {
matchRsult.add(hit.getSourceAsMap());
}
return matchRsult;
}
/**
* 删除指定类型的id
* @param indexName 索引名称
* @param type 类型
* @param id id
* @throws IOException 异常信息
*/
public static void deleteDocument(String indexName,String type,String id) throws Exception {
try {
DeleteRequest request = new DeleteRequest(indexName, type, id);
client.delete(request, RequestOptions.DEFAULT);
System.out.println("删除成功");
} catch(Throwable e) {
e.printStackTrace();
throw new BusinessException("插入数据异常");
}
}
/**
* 查询所有索引下的字段信息
* @param index
* @return
*/
public static List<Map<String, Object>> queryAll(String index) throws Exception {
// 创建查询对象SearchRequest
SearchRequest searchRequest = new SearchRequest(index);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 查询全部信息
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
// 获取搜索击中对象
SearchHits hits = searchResponse.getHits();
List<Map<String, Object>> matchRsult = new LinkedList<>();
// 将击中的数据放入到集合
for (SearchHit hit : hits.getHits()) {
matchRsult.add(hit.getSourceAsMap());
}
return matchRsult;
}
/**
* 根据id进行搜索->支持多id进行搜索
* @param index
* @return
*/
public static List<Map<String, Object>> queryAllById(String index,List<String> ids) throws Exception {
List<Map<String, Object>> matchRsult = new LinkedList<>();
if(!ValidateUtil.checkListIsNotEmpty(ids)){
return matchRsult;
}
// 创建查询对象SearchRequest
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
for (String id: ids) {
TermQueryBuilder termQueryBuilder = new TermQueryBuilder("id", id);
boolQueryBuilder.should(termQueryBuilder);
}
SearchRequest searchRequest = new SearchRequest(index);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(boolQueryBuilder);
searchRequest.source(searchSourceBuilder);
SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
// 获取搜索击中对象
SearchHits hits = response.getHits();
// 将击中的数据放入到集合
for (SearchHit hit : hits.getHits()) {
matchRsult.add(hit.getSourceAsMap());
}
return matchRsult;
}
/**
* 根据范围进行搜索
* @param index
* @return
*/
public static List<Map<String, Object>> queryAllByRange(String index,String type,String filed,String startValue,String endValue) throws Exception {
List<Map<String, Object>> matchRsult = new LinkedList<>();
SearchRequest searchRequest = new SearchRequest(index);
// SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
// sourceBuilder.from(0);
// sourceBuilder.size(10);
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(filed);
rangeQueryBuilder.gte(startValue);
rangeQueryBuilder.lte(endValue);
searchRequest.types(type);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(rangeQueryBuilder);
searchRequest.source(searchSourceBuilder);
SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
// 获取搜索击中对象
SearchHits hits = response.getHits();
// 将击中的数据放入到集合
for (SearchHit hit : hits.getHits()) {
matchRsult.add(hit.getSourceAsMap());
}
return matchRsult;
}
/**
* 获得指定type指定id的json数据
* @param indexName 索引名称
* @param type 类型
* @param id id
* @return Map
* @throws IOException
*/
public static Map getDocument(String indexName,String type, String id) throws IOException {
GetRequest request = new GetRequest(
indexName,
type,
id);
GetResponse response = client.get(request,RequestOptions.DEFAULT);
if (!response.isExists()) {
System.out.println("检查到服务器上 " + type + " id=" + id + "的文档不存在");
return null;
} else {
String source = response.getSourceAsString();
System.out.print("获取到服务器上 " + type + " id=" + id + "的文档内容是:");
System.out.println(source);
// 转化为map返回
return response.getSourceAsMap();
}
}
/**
* 插入指定type的对象数据
* @param indexName 索引名称
* @param type 类型名称
* @param object 对象数据
* @throws IOException
*/
public static void addDocument(String indexName,String type,Object object) throws Exception {
Map<String, Object> jsonMap = new HashMap<>();
// 将object转为map
jsonMap = Beanutil.bean2map(object);
Object obj = jsonMap.get("id");
if(obj == null){
throw new BusinessException("id为空,插入数据异常");
}
IndexRequest indexRequest = new IndexRequest(indexName, type, obj.toString())
.source(jsonMap);
client.index(indexRequest,RequestOptions.DEFAULT);
System.out.println("已经向ElasticSearch服务器增加barbase:" + object);
}
/**
* 插入指定type的对象数据(类型名称默认为对象的简单类名)
* @param indexName 索引名称
* @param object 对象数据
* @throws IOException
*/
public static void addDocument(String indexName,Object object) throws Exception {
if(object == null){
throw new BusinessException("对象信息为空,插入数据异常");
}
// 获取object的简单类名(这里必须是小写)
String simpleName = object.getClass().getSimpleName().toLowerCase();
Map<String, Object> jsonMap = new HashMap<>();
// 将object转为map
jsonMap = Beanutil.bean2map(object);
Object obj = jsonMap.get("id");
if(obj == null){
throw new BusinessException("id为空,插入数据异常");
}
IndexRequest indexRequest = new IndexRequest(indexName, simpleName, obj.toString())
.source(jsonMap);
client.index(indexRequest,RequestOptions.DEFAULT);
System.out.println("已经向ElasticSearch服务器增加barbase:" + object);
}
/**
* 校验是否存在该索引
* @param indexName 索引名称
* @return boolean
* @throws IOException
*/
private static boolean checkExistIndexV1(String indexName) throws IOException {
boolean result = true;
try {
OpenIndexRequest openIndexRequest = new OpenIndexRequest(indexName);
client.indices().open(openIndexRequest,RequestOptions.DEFAULT).isAcknowledged();
} catch (ElasticsearchStatusException ex) {
String m = "Elasticsearch exception [type=index_not_found_exception, reason=no such index]";
if (m.equals(ex.getMessage())) {
result = false;
}
}
if (result)
System.out.println("索引:" + indexName + " 是存在的");
else
System.out.println("索引:" + indexName + " 不存在");
return result;
}
/**
* 校验是否存在该索引
* @param indexName 索引名称
* @return boolean
* @throws IOException
*/
private static boolean checkExistIndexV2(String indexName) throws IOException {
GetIndexRequest request = new GetIndexRequest();
// 赋值索引名称
request.indices(indexName);
request.local(false);
request.humanReadable(true);
boolean exists = client.indices().exists(request,RequestOptions.DEFAULT) ;
return exists;
}
/**
* 删除索引
* @param indexName
* @throws IOException
*/
private static void deleteIndex(String indexName) throws IOException {
// 索引删除请求对象
DeleteIndexRequest request = new DeleteIndexRequest(indexName);
// 删除索引
client.indices().delete(request,RequestOptions.DEFAULT);
System.out.println("删除了索引:" + indexName);
}
/**
* 新增索引
* @param indexName 索引名称
* @throws IOException
*/
private static void createIndex(String indexName) throws IOException {
CreateIndexRequest request = new CreateIndexRequest(indexName);
IndicesClient indicesClient = client.indices();
indicesClient.create(request,RequestOptions.DEFAULT);
System.out.println("创建了索引:" + indexName);
}
/**
* 通过ID 更新数据
*
* @param object 要增加的数据
* @param index 索引,类似数据库
* @param type 类型,类似表
* @param id 数据ID
* @return
*/
public static void updateDataById(Object object, String index, String type, String id) throws Exception{
UpdateRequest updateRequest = new UpdateRequest();
Map<String, Object> jsonMap = Beanutil.bean2map(object);
// 注意doc()方法后的参数需要是json或者map格式,如果传入object格式,会报错:The number of object passed must be even but was [1]
updateRequest.index(index).type(type).id(id).doc(jsonMap);
client.update(updateRequest,RequestOptions.DEFAULT);
}
/**
* 使用分词查询
*
* @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
*/
public static 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 Exception{
return null;
}
/**
* 高亮结果集 特殊处理
*
* @param searchResponse
* @param highlightField
*/
private static List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
List<Map<String, Object>> sourceList = new ArrayList<>();
return sourceList;
}
/**
* 批量添加
* @param index 索引名称
* @param type 类型名称
* @param list 集合对象
* @return
* @throws Exception
*/
public static boolean bulkAdd(String index,String type,List<Object> list) throws Exception {
// 初始化BulkRequest对象
BulkRequest request = new BulkRequest();
if (ValidateUtil.checkListIsNotEmpty(list)) {
list.forEach((Object obj) -> {
// 先将obj转为map
Map<String, Object> jsonMap = Beanutil.bean2map(obj);
if (jsonMap != null && null != jsonMap.get("id")) {
request.add(new IndexRequest(index, type, jsonMap.get("id").toString())
.source(jsonMap));
}
});
BulkResponse bulk = client.bulk(request, RequestOptions.DEFAULT);
System.out.println("Status:" + bulk.status().name() + ",hasFailures:" + bulk.hasFailures());
// 状态为OK
if("OK".equals(bulk.status().name())) {
// 插入不为失败
if (bulk.hasFailures()) {
return false;
} else {
return true;
}
}else{
return false;
}
} else {
return false;
}
}
public static RestHighLevelClient getClient() {
return client;
}
public static void setClient(RestHighLevelClient client) {
ElasticSearchUtils.client = client;
}
public static void main(String[] args) throws Exception{
// createIndex("wemew");
// checkExistIndexV1("wemew");
// boolean flag = checkExistIndexV2("wemew");
// List<Map<String, Object>> list = search("accounts","barbase","city","成都",0,20);
// list.forEach((Map<String, Object> map) ->{
// System.out.println("map="+map);
// });
// deleteDocument("accounts","barbase","1");
/*List<Map<String, Object>> list = search("accounts","barbase","id","1",0,20);
list.forEach((Map<String, Object> map) ->{
System.out.println("map="+map);
});*/
// Map map = getDocument("accounts","barbase","1");
/*Barbase barbase = new Barbase();
barbase.setCity("北京");
barbase.setTel("15889898989");
barbase.setId("999");
barbase.setName("北京胡桃里");
addDocument("accounts",barbase);
// System.out.println("map="+map);
Map map = getDocument("accounts","barbase","999");
System.out.println("map="+map);*/
List list = new ArrayList();
User user = new User();
user.setCity("北京胡桃里");
user.setTel("15889898989");
user.setId("007");
user.setName("张三");
User user1 = new User();
user1.setCity("北京胡桃里1");
user1.setTel("158898989891");
user1.setId("0071");
user1.setName("张三1");
User user2 = new User();
user2.setCity("北京胡桃里2update");
user2.setTel("158898989892");
user2.setId("0072");
user2.setName("张三2");
list.add(user);
list.add(user1);
list.add(user2);
// deleteIndex("test");
/* addDocument("user","user",user);
// System.out.println("map="+map);
Map map = getDocument("user","user","007");
System.out.println("map="+map);*/
// bulkAdd("test","test",list);
//Map map = getDocument("test","test","007");
// System.out.println("map="+map);
//updateDataById(user2,"test","test","007");
//Map map1 = getDocument("test","test","007");
List<Map<String, Object>> lists = queryAllByRange("test","test","tel","158898989890","158898989891");
for(Map<String, Object> map:lists){
System.out.println("map="+map);
// Object obj = Beanutil.map2bean(map,User);
}
}
}
Beanutil.java
package com.dflm.weixin.elasticsearch;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.Map;
/**
* bean和map之间的转换工具类
* @author lh
* @version 1.0
*/
public class Beanutil {
/**
* 将JavaBean对象封装到Map集合当中
* @param bean
* @return
* @throws Exception
*/
public static Map<String, Object> bean2map(Object bean)
{
//创建Map集合对象
Map<String,Object> map=new HashMap<>();
try {
//获取对象字节码信息,不要Object的属性
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
//获取bean对象中的所有属性
PropertyDescriptor[] list = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor pd : list) {
String key = pd.getName();//获取属性名
Object value = pd.getReadMethod().invoke(bean);//调用getter()方法,获取内容
if (value != null) {
map.put(key, value);//增加到map集合当中
}
}
}catch(Exception e){
e.printStackTrace();
return null;
}
return map;
}
/**
* 将Map集合中的数据封装到JavaBean对象中
* @param map 集合
* @param classType 封装javabean对象
* @throws Exception
*/
public static <T> T map2bean(Map<String, Object> map,Class<T> classType) throws Exception
{
//采用反射动态创建对象
T obj = classType.newInstance();
//获取对象字节码信息,不要Object的属性
BeanInfo beanInfo = Introspector.getBeanInfo(classType,Object.class);
//获取bean对象中的所有属性
PropertyDescriptor[] list = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor pd : list) {
String key = pd.getName(); //获取属性名
Object value=map.get(key); //获取属性值
pd.getWriteMethod().invoke(obj, value);//调用属性setter()方法,设置到javabean对象当中
}
return obj;
}
}
以上就是对ES的个人理解,如果存在有误的地方,还请各位指正。