elasticsearch代码片段，及工具类SearchEsUtil.java
ElasticSearchClient.java
package com.zbiti.framework.elasticsearch.utils; import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.CollectionUtils;
import org.apache.log4j.Logger;
import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequestBuilder;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.cluster.ClusterState;
import org.elasticsearch.cluster.metadata.IndexMetaData;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.node.Node;
import org.elasticsearch.node.NodeBuilder; /**
* 创建索引的client
*
* @author cookey
*/
public class ElasticSearchClient {
private static Logger logger = Logger.getLogger(ElasticSearchClient.class);
private static Client searchClient = null;
private static List<String> clusterList = null; private ElasticSearchClient() {
} /**
* 创建client实例
*
* @return client
* */
public static synchronized Client getInstance() {
if (searchClient == null) {
open();
}
return searchClient;
} /*
* 创建搜索客户�?tcp连接搜索服务�?创建索引 创建mapping
*/
private static void open() {
try {
/**
* 如果100秒没有连接上搜索服务器，则超�?
* */
Settings settings = ImmutableSettings
.settingsBuilder()
// .put(this.searchClientConfigureMap)
.put("client.transport.ping_timeout", "100s")
.put("client.transport.sniff", "true")
.put("cluster.name",PropertyManager.getContextProperty("cluster.name"))
// .put("client.transport.ignore_cluster_name", "true")
.build();
/* 创建搜索客户�?*/
searchClient = new TransportClient(settings);
if (CollectionUtils.isEmpty(clusterList)) {
String cluster = PropertyManager.getContextProperty("search.clusterList");
if (cluster != null) {
clusterList = Arrays.asList(cluster.split(","));
}
}
for (String item : clusterList) {
String address = item.split(":")[0];
int port = Integer.parseInt(item.split(":")[1]);
/* 通过tcp连接搜索服务器，如果连接不上，有�?��可能是服务器端与客户端的jar包版本不匹配 */
searchClient = ((TransportClient) searchClient).addTransportAddress(new InetSocketTransportAddress(
address, port));
}
} catch (Exception e) {
logger.error(e.getMessage());
e.printStackTrace();
}
} /**
* 创建node对象
*
* @return client
* */
public static Client createClient() {
NodeBuilder builder = NodeBuilder.nodeBuilder();
String clusterName = PropertyManager.getContextProperty("cluster.name");
builder.clusterName(clusterName); Boolean isClient = Boolean.parseBoolean(PropertyManager
.getContextProperty("node.client"));
builder.client(isClient); Node node = builder.node();
/*
* Node node = nodeBuilder().clusterName("yourclustername").node();
* Client client = node.client();
*/
return node.client();
} /**
* 测试ES可用连接数方�?同时也也可以用以校验ES是否可以连接�?
*/
public static boolean testConnection(Client client) {
try {
/**
* 获得节点信息
* */
NodesInfoResponse response = client.admin().cluster()
.nodesInfo(new NodesInfoRequest().timeout("30"))
.actionGet();
// 获得集群名称
String cluNameString = response.getClusterNameAsString();
System.out.println(cluNameString);
// 获得节点名称
NodeInfo[] indexNameString = response.getNodes();
System.out.println(indexNameString[0].getNode().getName());
Map<String, NodeInfo> nodesMap = response.getNodesMap();
// 打印节点信息
for (Map.Entry<String, NodeInfo> entry : nodesMap.entrySet()) {
System.out.println(entry.getKey() + ":"
+ entry.getValue().getServiceAttributes());
}
if (nodesMap != null) {
return true;
}
/**
* 获得Mapping
* */
ClusterState cs = client.admin().cluster().prepareState()
.setFilterIndices("standard_test").execute().actionGet()
.getState(); IndexMetaData imd = cs.getMetaData().index("standard_test");
// type的名�?
MappingMetaData mdd = imd.mapping("standard_type_test");
System.out.println(mdd.sourceAsMap()); } catch (Exception e) {
e.printStackTrace();
System.out.println("无法连接到Elasticsearch");
}
return false;
} /**
* 索引库是否存�?
*
* @param client
* 客户�?
* @param index
* 索引库名
* @return 存在则返回true，不存在则返回false
*/
public static Boolean indexExist(Client client, String index) {
IndicesExistsRequest request = new IndicesExistsRequestBuilder(client
.admin().indices(), index).request();
IndicesExistsResponse response = client.admin().indices()
.exists(request).actionGet();
return response.isExists();
} }
ElasticSearchDao.java
package com.zbiti.framework.elasticsearch.utils; import java.util.List; import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.deletebyquery.DeleteByQueryResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHits; import com.zbiti.framework.base.entity.BaseEntity;
/**
* ElasticSearch操作接口
*
* @author LICHANGWU
*
*/
public interface ElasticSearchDao { // -------------------------创建索引-----------------------------
/**
* 根据对象实例的json串创建索引(单条索引).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param indexId
* 建立索引的唯一标识ID
* @param jsonStr
* 索引对象实例的对应json串
* @author LICHANGWU
*/
public IndexResponse createIndexByJson(String indexName, String indexType,
String indexId, String jsonStr); /**
* 根据对象集合批量索引(多条批量)
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param surplusGoodsEntitys
* 对象集合
*/
public void createIndexsByBeans(String indexName, String indexType,
List<BaseEntity> entry); // ------------------------------------查询------------------------------------------------- /**
* 根据索引唯一标识ID查找对象().
*
* @param indexName
* 索引组名
*
* @param indexType
* 索引类型
* @param queryName
* 查询字段名
* @param queryValue
* 查询字段值
* @param PageInfo
* 分页情况
*
* @author LICHANGWU
*/
public List<Object> searchById(String indexName, String indexType,
String queryName, String queryValue, PageInfo pageInfo); /**
* 根据传入的值进行模糊查询(分页查询).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
* @return
*/
/**
* 根据传入的值进行模糊查询(分页查询).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
* @return
* @throws Exception
*/
public List search(String indexName, String indexType,
List<QueryBuilder> bqbl,List<FilterBuilder> fbList,String[] highLighterFields, PageInfo pageInfo, Class cls,List<Order> orders)
throws Exception; /**
* 根据传入的值进行模糊查询(分组查询个数).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
*
* @param groupFiled
* 分页字段
* @return
* @throws Exception
*/
public List searchCount(String indexName, String indexType,
List<QueryBuilder> bqbl, List<FilterBuilder> fbList,PageInfo pageInfo,String groupFiled); public SearchHits searchByOnlyValue(String indexName, String indexType,
String queryValue, PageInfo pageInfo) ; // -----------------------删除---（暂且完结）---------------------- /**
* 根据指定属性键值对删除索引(查询删除).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param name
* 删除依据的字段属性名
* @param value
* 删除依据的字段属性值
*/
public DeleteByQueryResponse deleteIndexByNameAndValue(String indexName,
String indexType, String name, String value); /**
* 根据索引的Id删除索引(单条删除).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param Id
* 指定索引文档Id
*/
public DeleteResponse deleteIndexById(String indexName, String indexType,
String Id); /**
* 根据索引的Id集合删除索引(批量删除).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param Ids
* 指定索引文档Id集合
*/
public void deleteIndexByIds(String indexName, String indexType,
List<String> Ids); /**
* 删除确定索引组和索引类型下所有数据(危险，慎用).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*/
public void deleteAllIndex(String indexName, String indxType); // --------------------------更新索引------------------------ /**
* 根据ID更新索引(单条更新).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param obj
* 更新数据
* @param Id
* 更新条件Id
*
*/
public void updateIndex(String indexName, String indexType,
BaseEntity entry, String Id); }
ElasticSearchDaoImpl.java
package com.zbiti.framework.elasticsearch.utils; import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map; import net.sf.json.JSONObject; import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.deletebyquery.DeleteByQueryResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.FilterBuilders;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.facet.FacetBuilders;
import org.elasticsearch.search.facet.terms.TermsFacet;
import org.elasticsearch.search.facet.terms.TermsFacetBuilder;
import org.elasticsearch.search.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.stereotype.Service; import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.zbiti.framework.base.entity.BaseEntity; /**
* ElasticSearch操作接口实现
*
* @author LICHANGWU
*
*/
@Service
public class ElasticSearchDaoImpl implements ElasticSearchDao {
Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd").create(); // -------------------------创建索引----------------------------- /**
* 根据对象实例的json串创建索引.
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param indexId
* 建立索引的唯一标识ID
* @param jsonStr
* 索引对象实例的对应json串
* @author LICHANGWU
*/
public IndexResponse createIndexByJson(String indexName, String indexType,
String indexId, String jsonStr) {
Client client = ElasticSearchClient.getInstance();
IndexResponse response = client.prepareIndex(indexName, indexType,
indexId).setSource(jsonStr).execute().actionGet();
System.out.println(response.getId());
return response; } /**
* 根据对象集合批量索引(多条批量)
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param surplusGoodsEntitys
* 对象集合
*/
public void createIndexsByBeans(String indexName, String indexType,
List<BaseEntity> entry) {
Client client = ElasticSearchClient.getInstance();
BulkRequestBuilder builder = client.prepareBulk();
for (BaseEntity g : entry) {
String jsonStr = gson.toJson(g);
String id = g.getId();
builder.add(client.prepareIndex(indexName, indexType, id)
.setSource(jsonStr).request());
}
builder.execute().actionGet(); } // ------------------------------------查询------------------------------------------------- /**
* 根据索引唯一标识ID查找对象.
*
* @param indexName
* 索引组名
*
* @param indexType
* 索引类型
* @param queryName
* 查询字段名
* @param queryValue
* 查询字段值
* @param PageInfo
* 分页情况
*
* @author LICHANGWU
*/
public List<Object> searchById(String indexName, String indexType,
String queryName, String queryValue, PageInfo pageInfo) {
Client client = ElasticSearchClient.getInstance(); return null;
} /**
* 根据传入的值进行模糊查询(分页查询).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
* @return
* @throws Exception
*/
public List search(String indexName, String indexType,
List<QueryBuilder> bqbl, List<FilterBuilder> fbList,
String[] highLighterFields, PageInfo pageInfo, Class cls,
List<Order> orders) throws Exception {
Client client = ElasticSearchClient.getInstance();
int pageIndex = 0;
int pageSize = 0;
int from = 0;
BoolQueryBuilder boolQueryBuilderTotal = QueryBuilders.boolQuery();
if (bqbl != null) {
for (QueryBuilder bqb : bqbl) {
boolQueryBuilderTotal.must(bqb);
}
} SearchRequestBuilder searchRequestBuilder = client.prepareSearch(
indexName).setTypes(indexType);
if (fbList != null) {
for (FilterBuilder fb : fbList) {
searchRequestBuilder.setFilter(fb);
}
}
searchRequestBuilder.setQuery(boolQueryBuilderTotal).setExplain(true);
if (pageInfo != null) {
pageIndex = pageInfo.getCurrPage();
pageSize = pageInfo.getPageSize();
from = (pageIndex - 1) * pageSize;
searchRequestBuilder.setFrom(from).setSize(pageSize);
} if (orders != null && orders.size() > 0) {
/* 如果需要排序 */
for (Order order : orders) {
if (!"".equals(order.getField()) && null != order.getField()) {
org.elasticsearch.search.sort.SortOrder sortOrder = "desc"
.equals(order.getSort()) ? SortOrder.DESC
: SortOrder.ASC;
searchRequestBuilder = searchRequestBuilder.addSort(order
.getField(), sortOrder);
}
} }
if (highLighterFields != null && highLighterFields.length > 0) {
String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
if(!"genernalReport".equals(methodName)){ //非导出excel表格时，添加样式
// 设置高亮显示
for (String field : highLighterFields) {
searchRequestBuilder.addHighlightedField(field);
}
searchRequestBuilder.setHighlighterPreTags("<span style=\"color:red;\">");
searchRequestBuilder.setHighlighterPostTags("</span>");
}
}
SearchResponse searchResponse = searchRequestBuilder.execute()
.actionGet(); SearchHits hits = searchResponse.getHits(); SearchHit[] hts = hits.getHits();
List list = convert(hts, cls);
if (pageInfo != null) {
pageInfo.setTotal((int) hits.getTotalHits());
pageInfo.setResult(list);
}
return list;
} /**
* 根据传入的值进行模糊查询(分组查询个数).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
*
* @param groupFiled
* 分页字段
* @return
* @throws Exception
*/
public List searchCount(String indexName, String indexType,
List<QueryBuilder> bqbl, List<FilterBuilder> fbList,PageInfo pageInfo,String groupFiled){
Client client = ElasticSearchClient.getInstance();
int pageIndex = 0;
int pageSize = 0;
int from = 0;
BoolQueryBuilder boolQueryBuilderTotal = QueryBuilders.boolQuery();
if (bqbl != null) {
for (QueryBuilder bqb : bqbl) {
boolQueryBuilderTotal.must(bqb);
}
} SearchRequestBuilder searchRequestBuilder = client.prepareSearch(
indexName).setTypes(indexType);
if (fbList != null) {
for (FilterBuilder fb : fbList) {
searchRequestBuilder.setFilter(fb);
}
} searchRequestBuilder.setQuery(boolQueryBuilderTotal).setExplain(true);
if (pageInfo != null) {
pageIndex = pageInfo.getCurrPage();
pageSize = pageInfo.getPageSize();
from = (pageIndex - 1) * pageSize;
searchRequestBuilder.setFrom(from).setSize(pageSize);
}
TermsFacetBuilder facetBuilder = FacetBuilders.termsFacet(groupFiled).field(groupFiled).size(Integer.MAX_VALUE);
SearchResponse searchResponse = searchRequestBuilder.addFacet(facetBuilder).execute()
.actionGet(); List<Map> groupList = new ArrayList<Map>();
List<Map> resultList = new ArrayList<Map>();
TermsFacet tf = (TermsFacet)searchResponse.getFacets().facetsAsMap().get(groupFiled);
for (TermsFacet.Entry entry : tf) {
Map<String,Object> modelMap = new HashMap<String,Object>();
modelMap.put(groupFiled, entry.getTerm().toString());
modelMap.put("count", entry.getCount());
groupList.add(modelMap);
}
for(int i=0; i<10; i++){
int index = from + i;
if(index >= groupList.size()){
break;
}
resultList.add(groupList.get(index));
}
if (pageInfo != null) {
pageInfo.setTotal(groupList.size());
pageInfo.setResult(resultList);
}
return resultList;
} /**
* 根据传入的值进行模糊查询(分页查询).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*
* @param queryMap
* key 查询条件 value 字段域
* @param pageInfo
* 分页信息
* @return
* @throws Exception
*/
public SearchHits searchByOnlyValue(String indexName, String indexType,
String queryValue, PageInfo pageInfo) {
Client client = ElasticSearchClient.getInstance();
int pageIndex = pageInfo.getCurrPage();
int pageSize = pageInfo.getPageSize();
int from = (pageIndex - 1) * pageSize;
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
QueryBuilder qu = QueryBuilders.fuzzyQuery("deviceName", queryValue);
boolQueryBuilder.should(qu);
SearchRequestBuilder searchRequestBuilder = client.prepareSearch(
indexName).setTypes(indexType).setQuery(boolQueryBuilder)
.setFrom(from).setSize(pageSize).addHighlightedField(
"deviceName").setHighlighterEncoder("UTF-8")
.setHighlighterPreTags("<font class='font-highlight'>")
.setHighlighterPostTags("</font>").setExplain(true);
SearchResponse searchResponse = searchRequestBuilder.execute()
.actionGet();
SearchHits hits = searchResponse.getHits(); return hits;
} /**
* 转化成实例对象的集合
*
* @param hts
* @param cls
* @return
* @throws Exception
*/
private List convert(SearchHit[] hts, Class cls) throws Exception {
List list = new ArrayList();
List<Field> fields = new ArrayList<Field>();
getAllFields(cls, fields); for (SearchHit sh : hts) {
Object obj = cls.newInstance();
// 获取对应的高亮域
Map<String, HighlightField> result = sh.highlightFields();
for (Field f : fields) {
Object value = "";
if (result != null && result.size() > 0) {
// 从设定的高亮域中取得指定域
HighlightField titleField = result.get(f.getName());
if (titleField != null) {
// 取得定义的高亮标签
Text[] titleTexts = titleField.fragments();
// 为title串值增加自定义的高亮标签
for (Text text : titleTexts) {
value = String.valueOf(value) + text;
}
}
}
if ("".equals(value) || null == value) {
value = sh.getSource().get(f.getName());
} Class<?> type = f.getType();
Method m = cls.getMethod("set".concat(
f.getName().substring(0, 1).toUpperCase()).concat(
f.getName().substring(1)), new Class[] { type }); if (m != null) {
if (value != null && !"".equals(value)) {
if (type == String.class) {
m.invoke(obj,
new Object[] { String.valueOf(value) });
} else if (type == Integer.class || type == int.class) {
m.invoke(obj, new Object[] { new Integer(String
.valueOf(value)) });
} else if (type == Double.class || type == double.class) {
m.invoke(obj, new Object[] { new Double(String
.valueOf(value)) });
} else if (type == Date.class) {
Map timeMap = (Map) value;
Long time = (Long) timeMap.get("time");
m.invoke(obj, new Object[] { new Date(time) });
} else if (type == Boolean.class
|| type == boolean.class) {
m.invoke(obj, new Object[] { new Boolean(String
.valueOf(value)) });
} else if (type == Long.class || type == long.class) {
m.invoke(obj, new Object[] { new Long(String
.valueOf(value)) });
} else {
throw new Exception("暂时无法赋值到" + type.getName()
+ "类型的属性中");
}
}
}
}
list.add(obj);
}
return list;
} /**
* 递归获取类所有属性包含父类属性
*
* @param cls
* @param list
*/
private void getAllFields(Class cls, List<Field> list) {
Field[] f = cls.getDeclaredFields();
List<Field> l = Arrays.asList(f);
list.addAll(l); Class superc = cls.getSuperclass();
if (superc != null) {
getAllFields(superc, list);
}
} // -----------------------删除---（暂且完结）----------------------
/**
* 根据指定属性键值对删除索引(查询删除).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param name
* 删除依据的字段属性名
* @param value
* 删除依据的字段属性值
*/
public DeleteByQueryResponse deleteIndexByNameAndValue(String indexName,
String indexType, String name, String value) {
Client client = ElasticSearchClient.getInstance();
QueryBuilder queryBuiler = QueryBuilders.fieldQuery(name, value);
DeleteByQueryResponse response = client.prepareDeleteByQuery(indexName)
.setQuery(queryBuiler).execute().actionGet();
return response;
} /**
* 根据索引的Id删除索引.
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param Id
* 指定索引文档Id
*/
public DeleteResponse deleteIndexById(String indexName, String indexType,
String Id) {
Client client = ElasticSearchClient.getInstance();
DeleteResponse response = client
.prepareDelete(indexName, indexType, Id).execute().actionGet();
return response; } /**
* 根据索引的Id集合删除索引(批量删除).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param Ids
* 指定索引文档Id集合
*/
public void deleteIndexByIds(String indexName, String indexType,
List<String> Ids) {
Client client = ElasticSearchClient.getInstance();
BulkRequestBuilder builder = client.prepareBulk();
for (String id : Ids) {
builder.add(client.prepareDelete(indexName, indexType, id)
.request());
}
builder.execute().actionGet();
} /**
* 删除确定索引组和索引类型下所有数据(危险，慎用).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
*/
public void deleteAllIndex(String indexName, String indxType) {
Client client = ElasticSearchClient.getInstance();
client.prepareDeleteByQuery(indexName).setTypes(indxType).setQuery(
QueryBuilders.matchAllQuery()).execute().actionGet(); } /**
* 根据ID更新索引(单条更新).
*
* @param indexName
* 索引组名
* @param indexType
* 索引类型
* @param obj
* 更新数据
* @param Id
* 更新条件Id
*
*/
public void updateIndex(String indexName, String indexType,
BaseEntity entry, String Id) {
Client client = ElasticSearchClient.getInstance();
client.prepareDelete(indexName, indexType, Id).execute().actionGet();
JSONObject jsonstr = JSONObject.fromObject(entry);
IndexResponse response = client.prepareIndex(indexName, indexType, Id)
.setSource(jsonstr.toString()).execute().actionGet();
System.out.println(response.getId()); } public static void main(String[] args) {
ElasticSearchDaoImpl ed = new ElasticSearchDaoImpl();
// ed.deleteAllIndex("supdem_index","supdem_index_type");
} }
Order.java
package com.zbiti.framework.elasticsearch.utils;
public class Order {
private String field;
private String sort;
public Order(){}
public Order(String field,String sort){
this.field = field;
this.sort = sort;
}
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
public String getSort() {
return sort;
}
public void setSort(String sort) {
this.sort = sort;
}
}
OrderInfo.java
package com.zbiti.framework.elasticsearch.utils;
public class OrderInfo {
private String field;
private boolean sort;
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
public boolean isSort() {
return sort;
}
public void setSort(boolean sort) {
this.sort = sort;
}
}
PageInfo.java
package com.zbiti.framework.elasticsearch.utils; import java.util.List; /**
* ElasticSearch查询分页信息
*
* @author LICHANGWU
*
*/
public class PageInfo { private int pageSize;
private int total;
private int totalPage;
private int currPage; private List result; public PageInfo(){ } public PageInfo(int currPage,int pageSize){
this.currPage= currPage;
this.pageSize = pageSize;
} public int getPageSize() {
return pageSize;
} public void setPageSize(int pageSize) {
this.pageSize = pageSize;
} public int getTotal() {
return total;
} public void setTotal(int total) {
this.total = total;
this.totalPage = this.total%this.pageSize == 0?this.total/this.pageSize : this.total/this.pageSize + 1;
} public int getTotalPage() {
return totalPage;
} public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
} public int getCurrPage() {
return currPage;
} public void setCurrPage(int currPage) {
this.currPage = currPage;
} public List getResult() {
return result;
} public void setResult(List result) {
this.result = result;
}
}
SearchEsUtil.java
package com.zbiti.framework.elasticsearch.utils; import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set; import org.elasticsearch.index.query.BoolFilterBuilder;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.FilterBuilders;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders; public class SearchEsUtil { /**
* 多个查询条件在一个域中查询 ：或关系
* @param query
* @return
*/
public static QueryBuilder appendMulToOneOrRelation(String[] query,String queryArea){
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
for(String que : query){
QueryBuilder qu =QueryBuilders.fieldQuery(queryArea,"\""+que+"\"").analyzer(null).analyzeWildcard(false);
boolQueryBuilder.should(qu);
}
return boolQueryBuilder;
} /**
* 一个查询条件在多个域中查询 ：或关系
* @param query
* @return
*/
public static QueryBuilder appendOneToMulOrRelation(String query,String[] queryArea,boolean fz){
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
if(!fz){
query = "\""+query+"\"";
for(String que : queryArea){
QueryBuilder qu =QueryBuilders.fieldQuery(que,query).analyzer(null).analyzeWildcard(false);
boolQueryBuilder.should(qu);
}
return boolQueryBuilder;
}else{
MultiMatchQueryBuilder mulqueryBuilder = QueryBuilders.multiMatchQuery(query, queryArea);
BoolQueryBuilder builder = boolQueryBuilder.should(mulqueryBuilder);
return builder;
}
} /**
* 一个查询条件在一个域中查询:且关系
* @param query
* @param queryArea
* @return
*/
public static QueryBuilder appendOneToOneAndRelation(String query,String queryArea){
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
QueryBuilder qu =QueryBuilders.fieldQuery(queryArea,"\""+query+"\"").analyzer(null).analyzeWildcard(false);
boolQueryBuilder.must(qu);
return boolQueryBuilder;
} /**
* 时间过滤
* @param start
* @param end
* @param queryArea
* @return
*/
public static FilterBuilder appendTimeRelation(String start,String end,String queryArea){
BoolFilterBuilder qu = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter(queryArea).from(start).to(end));
return qu;
} /**
* 组合查询条件分组转化
* @param mulQuery
* @return
*/
public static Map<String,String[]> mulQueryToMap(String mulQuery){
Map<String,String[]> mulMap = new HashMap<String,String[]>();
if(null != mulQuery && !"".equals(mulQuery)){
String[] querys = mulQuery.split(",");
Set<String> keyS = new HashSet<String>();
List<String> vals = new ArrayList<String>();
for(String query:querys){
if(null != query && !"".equals(query)){
String[] s = query.split("_");
keyS.add(s[0]);
vals.add(query);
}
}
for(String key:keyS){
List<String> tol = new ArrayList<String>();
for(String val : vals){
if(val.contains(key)){
tol.add(val.split("_")[1]);
}
}
mulMap.put(key,tol.toArray(new String[tol.size()]));
}
}
return mulMap;
}
}
SurplusGoodsEntity.java
package com.zbiti.framework.elasticsearch.utils; import java.io.Serializable;
import java.util.Date; /**
* 闲置资源实体类.
*
* @author LICHANGWU
*
*/
public class SurplusGoodsEntity implements Serializable { /**
* serialVersionUID.
*/
private static final long serialVersionUID = -5266853903541167616L;
/**
* 唯一标识ID
*/
private String id; /**
* 正式库资源ID.
*/
private int deviceId;
/**
* 资源编号.
*/
private String deviceNo;
/**
* 专业.
*/
private String specialty;
/**
* 网元.
*/
private String netType;
/**
* 设备型号.
*/
private int modelId;
/**
* 资产目录.
*/
private int assId;
/**
* 设备名称.
*/
private String deviceName;
/**
* 干线级别.
*/
private String trunkLine;
/**
* 公司编码.
*/
private String companyCode;
/**
* 部门编码.
*/
private String departmentCode;
/**
* 维护人.
*/
private String maintenceMan;
/**
* 存放位置.
*/ private String place;
/**
* 原值.
*/
private double originalValue;
/**
* 净值.
*/
private double netValue;
/**
* 数据来源.
*/
private String dataSource;
/**
* 开始使用时间.
*/
private Date useDate;
/**
* 开始闲置时间.
*/
private Date beginDate;
/**
* 资源卡片编号.
*/
private String cardNo;
/**
* 资产属性.
*/
private String assetProperty;
/**
* 计量单位.
*/
private String unit;
/**
* 录入方式.
*/
private String inputWay;
/**
* 闲置原因.
*/
private String leaveuseWhy;
/**
* 使用年限.
*/
private String liftSpan;
/**
* 库存.
*/
private int ctockNum;
/**
* 是否可用.
*/
private String disable;
/**
* 调拨次数.
*/
private String allocateCount;
/**
* 是否上架.
*/
private String isShelves;
/**
* 浏览次数.
*/
private int browseCount;
/**
* 点击量.
*/
private int scanTotal;
/**
* 排序.
*/
private int sort; /**
* 获取唯一标识ID.
*/
public String getId() {
return id;
} /**
* 设置唯一标识ID.
*/
public void setId(String id) {
this.id = id;
} /**
* 获取正式库资源ID.
*/
public int getDeviceId() {
return deviceId;
} /**
* 设置正式库资源ID.
*/
public void setDeviceId(int deviceId) {
this.deviceId = deviceId;
} /**
* 获取资源编号.
*/
public String getDeviceNo() {
return deviceNo;
} /**
*设置 资源编号.
*/
public void setDeviceNo(String deviceNo) {
this.deviceNo = deviceNo;
} /**
* 获取专业.
*/
public String getSpecialty() {
return specialty;
} /**
* 设置专业.
*/
public void setSpecialty(String specialty) {
this.specialty = specialty;
} /**
* 获取网元.
*/
public String getNetType() {
return netType;
} /**
*设置 网元.
*/
public void setNetType(String netType) {
this.netType = netType;
} /**
* 获取设备型号.
*/
public int getModelId() {
return modelId;
} /**
* 设置设备型号.
*/
public void setModelId(int modelId) {
this.modelId = modelId;
} /**
* 获取资产目录.
*/
public int getAssId() {
return assId;
} /**
* 设置资产目录.
*/
public void setAssId(int assId) {
this.assId = assId;
} /**
* 获取设备名称.
*/
public String getDeviceName() {
return deviceName;
} /**
* 设置设备名称.
*/
public void setDeviceName(String deviceName) {
this.deviceName = deviceName;
} /**
* 获取干线级别.
*/
public String getTrunkLine() {
return trunkLine;
} /**
* 设置干线级别.
*/
public void setTrunkLine(String trunkLine) {
this.trunkLine = trunkLine;
} /**
* 获取公司编码.
*/
public String getCompanyCode() {
return companyCode;
} /**
* 设置公司编码.
*/
public void setCompanyCode(String companyCode) {
this.companyCode = companyCode;
} /**
* 获取部门编码.
*/
public String getDepartmentCode() {
return departmentCode;
} /**
* 设置部门编码.
*/
public void setDepartmentCode(String departmentCode) {
this.departmentCode = departmentCode;
} /**
* 获取维护人.
*/
public String getMaintenceMan() {
return maintenceMan;
} /**
* 设置维护人.
*/
public void setMaintenceMan(String maintenceMan) {
this.maintenceMan = maintenceMan;
} /**
* 获取存放位置.
*/
public String getPlace() {
return place;
} /**
* 设置存放位置.
*/
public void setPlace(String place) {
this.place = place;
} /**
* 获取原值.
*/
public double getOriginalValue() {
return originalValue;
} /**
*设置 原值.
*/
public void setOriginalValue(double originalValue) {
this.originalValue = originalValue;
} /**
* 获取净值.
*/
public double getNetValue() {
return netValue;
} /**
* 设置净值.
*/
public void setNetValue(double netValue) {
this.netValue = netValue;
} /**
* 获取数据来源.
*/
public String getDataSource() {
return dataSource;
} /**
* 设置数据来源.
*/
public void setDataSource(String dataSource) {
this.dataSource = dataSource;
} /**
* 获取开始使用时间.
*/
public Date getUseDate() {
return useDate;
} /**
* 设置开始使用时间.
*/
public void setUseDate(Date useDate) {
this.useDate = useDate;
} /**
* 获取开始闲置时间.
*/
public Date getBeginDate() {
return beginDate;
} /**
* 设置开始闲置时间.
*/
public void setBeginDate(Date beginDate) {
this.beginDate = beginDate;
} /**
* 获取资源卡片编号.
*/
public String getCardNo() {
return cardNo;
} /**
*设置 资源卡片编号.
*/
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
} /**
* 获取资产属性.
*/
public String getAssetProperty() {
return assetProperty;
} /**
* 设置资产属性.
*/
public void setAssetProperty(String assetProperty) {
this.assetProperty = assetProperty;
} /**
* 获取计量单位.
*/
public String getUnit() {
return unit;
} /**
* 设置计量单位.
*/
public void setUnit(String unit) {
this.unit = unit;
} /**
* 获取录入方式.
*/
public String getInputWay() {
return inputWay;
} /**
* 设置录入方式.
*/
public void setInputWay(String inputWay) {
this.inputWay = inputWay;
} /**
* 获取闲置原因.
*/
public String getLeaveuseWhy() {
return leaveuseWhy;
} /**
* 设置闲置原因.
*/
public void setLeaveuseWhy(String leaveuseWhy) {
this.leaveuseWhy = leaveuseWhy;
} /**
* 获取使用年限.
*/
public String getLiftSpan() {
return liftSpan;
} /**
* 设置使用年限.
*/
public void setLiftSpan(String liftSpan) {
this.liftSpan = liftSpan;
} /**
* 获取库存.
*/
public int getCtockNum() {
return ctockNum;
} /**
* 设置库存.
*/
public void setCtockNum(int ctockNum) {
this.ctockNum = ctockNum;
} /**
* 获取是否可用.
*/
public String getDisable() {
return disable;
} /**
* 设置是否可用.
*/
public void setDisable(String disable) {
this.disable = disable;
} /**
* 获取调拨次数.
*/
public String getAllocateCount() {
return allocateCount;
} /**
* 设置调拨次数.
*/
public void setAllocateCount(String allocateCount) {
this.allocateCount = allocateCount;
} /**
* 获取是否上架.
*/
public String getIsShelves() {
return isShelves;
} /**
* 设置是否上架.
*/ public void setIsShelves(String isShelves) {
this.isShelves = isShelves;
} /**
*获取 浏览次数.
*/
public int getBrowseCount() {
return browseCount;
} /**
* 设置浏览次数.
*/
public void setBrowseCount(int browseCount) {
this.browseCount = browseCount;
} /**
* 获取点击量.
*/
public int getScanTotal() {
return scanTotal;
} /**
* 设置点击量.
*/
public void setScanTotal(int scanTotal) {
this.scanTotal = scanTotal;
} /**
* 获取排序.
*/
public int getSort() {
return sort;
} /**
* 设置排序.
*/
public void setSort(int sort) {
this.sort = sort;
} }
PropertyManager.java
package com.zbiti.framework.elasticsearch.utils; import java.io.File;
import java.io.FileInputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties; /**
* 资源文件管理
*
* @author LICHANGWU
*
*/
public class PropertyManager {
private static Map<String, String> ctxPropertiesMap = null;
static {
try { String path = PropertyManager.class.getResource("/").getPath(); File dic = new File(path);
ctxPropertiesMap = new HashMap<String, String>();
for (File file : dic.listFiles()) {
if (file.getName().endsWith(".properties")) {
Properties prop = new Properties();
prop.load(new FileInputStream(file));
Enumeration<Object> keys = prop.keys();
while (keys.hasMoreElements()) {
String key = keys.nextElement().toString();
String value = prop.getProperty(key);
value = new String(value.getBytes("ISO-8859-1"),"UTF-8");
ctxPropertiesMap.put(key, value);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 获取配置属
*
* @param name
* @return String
*/
public static String getContextProperty(String name) {
return (String) ctxPropertiesMap.get(name);
}
}
elasticsearch代码片段，及工具类SearchEsUtil.java的更多相关文章
- Java 通过Xml导出Excel文件，Java Excel 导出工具类，Java导出Excel工具类
Java 通过Xml导出Excel文件,Java Excel 导出工具类,Java导出Excel工具类 ============================== ©Copyright 蕃薯耀 20 ...
- Java日期工具类，Java时间工具类，Java时间格式化
Java日期工具类,Java时间工具类,Java时间格式化 >>>>>>>>>>>>>>>>>&g ...
- Java字符串转16 进制工具类Hex.java
Java字符串转16 进制工具类Hex.java 学习了:https://blog.csdn.net/jia635/article/details/56678086 package com.strin ...
- Java Cookie工具类，Java CookieUtils 工具类，Java如何增加Cookie
Java Cookie工具类,Java CookieUtils 工具类,Java如何增加Cookie >>>>>>>>>>>>& ...
- UrlUtils工具类，Java URL工具类，Java URL链接工具类
UrlUtils工具类,Java URL工具类,Java URL链接工具类 >>>>>>>>>>>>>>>&g ...
- [Google Guava] 2.3-强大的集合工具类：java.util.Collections中未包含的集合工具
原文链接 译文链接 译者:沈义扬,校对:丁一 尚未完成: Queues, Tables工具类 任何对JDK集合框架有经验的程序员都熟悉和喜欢java.util.Collections包含的工具方法.G ...
- java基础课程笔记 static 主函数 静态工具类 classpath java文档注释 静态代码块 对象初始化过程 设计模式 继承 子父类中的函数 继承中的构造函数 对象转型 多态 封装 抽象类 final 接口 包 jar包
Static那些事儿 Static关键字 被static修饰的变量成为静态变量(类变量) 作用:是一个修饰符,用于修饰成员(成员变量,成员方法) 1.被static修饰后的成员变量只有一份 2.当成员 ...
- Android开发之SDCardUtils工具类。java工具详细代码，附源代码。判断SD卡是否挂载等功能
package com.xiaobing.zhbj.utils; import java.io.BufferedInputStream; import java.io.BufferedOutputSt ...
- 正则表达式验证工具类RegexUtils.java
Java 表单注册常用正则表达式验证工具类,常用正则表达式大集合. 1. 电话号码 2. 邮编 3. QQ 4. E-mail 5. 手机号码 6. URL 7. 是否为数字 8. 是否为中文 9. ...
随机推荐
- PAT 甲级 1079 Total Sales of Supply Chain
https://pintia.cn/problem-sets/994805342720868352/problems/994805388447170560 A supply chain is a ne ...
- Military Problem CodeForces - 1006E(dfs搜一下 标记一下)
题意: 就是有一颗树 然后每次询问 父结点 的 第k个结点是不是他的子嗣...是的话就输出这个子嗣..不是 就输出-1 解析: 突然想到后缀数组的sa 和 x的用法..就是我们可以用一个id标记当前 ...
- Docker中Spring boot+VueJS+MongoDB的前后端分离哲学摔跤
此文献给对数据有热情,想长期从事此行业的年轻人,希望对你们有所启发,并快速调整思路和方向,让自己的职业生涯有更好的发展. 根据数据应用的不同阶段,本文将从数据底层到最后应用,来谈谈那些数据人的必备技能 ...
- 【转】crc16几种标准校验算法及c语言代码
一.CRC16校验码的使用 现选择最常用的CRC-16校验,说明它的使用方法. 根据Modbus协议,常规485通讯的信息发送形式如下: 地址 功能码 数据信息 校验码 1byte 1byte nby ...
- 【bzoj2434】 Noi2011—阿狸的打字机
http://www.lydsy.com/JudgeOnline/problem.php?id=2434 (题目链接) 题意 给出一个字符串,$P$表示输出,$B$表示退格.$m$组询问$(x,y)$ ...
- 【bzoj1040】 ZJOI2008—骑士
http://www.lydsy.com/JudgeOnline/problem.php?id=1040 (题目链接) 题意 一个基环森林,从中选出不相邻的若干个点使得这些点的点权和最大. Solut ...
- POJ 2135 Farm Tour （网络流，最小费用最大流）
POJ 2135 Farm Tour (网络流,最小费用最大流) Description When FJ's friends visit him on the farm, he likes to sh ...
- 【CF771A】Bear and Friendship Condition
题目大意:给定一张无向图,要求如果 A 与 B 之间有边,B 与 C 之间有边,那么 A 与 C 之间也需要有边.问这张图是否满足要求. 题解:根据以上性质,即:A 与 B 有关系,B 与 C 有关系 ...
- python之旅：网络编程
一 客户端/服务器架构 1.硬件C/S架构(打印机) 2.软件C/S架构 互联网中处处是C/S架构 如黄色网站是服务端,你的浏览器是客户端(B/S架构也是C/S架构的一种) 腾讯作为服务端为你提供视频 ...
- 团体程序设计天梯赛-L3-021 神坛 的一些错误做法 和 一些想法
https://pintia.cn/problem-sets/994805046380707840/problems/994805046577840128 错误做法: 极角排序 + 最小三角形的两边是 ...