Elasticsearch的使用

最新推荐文章于 2022-05-20 20:02:47 发布

diaofu4842

最新推荐文章于 2022-05-20 20:02:47 发布

阅读量116

点赞数

文章标签：大数据 json 网络

原文链接：http://www.cnblogs.com/shuiqian/p/11118770.html

版权

我这边是以elasticsearch-2.4.3为例：引入maven

<dependency>
　　　　<groupId>org.elasticsearch.client</groupId>
　　　　<artifactId>transport</artifactId>
　　　　<version>6.4.3</version>
　　</dependency>

<groupId>org.apache.logging.log4j</groupId>

</dependency>

1、创建连接器：

import org.elasticsearch.client.transport.TransportClient;  
import org.elasticsearch.common.settings.Settings;  
import org.elasticsearch.common.transport.InetSocketTransportAddress;  
  
import java.net.InetAddress;  
import java.net.UnknownHostException;  
  
public class EsTcpClient {  

 private static TransportClient client;  
  
    /** 
     * 获取TCP 客户端 
     * 
     * @return 
     */  
    public static synchronized TransportClient getClient() {  
        if (client == null) {  
            build();  
        }  
        return client;  
    }  
  
    /** 
     * 关闭客户端 
     */  
    public static void close() {  
        if (client != null) {  
            client.close();  
        }  
    }  
  
    /** 
     * 建立连接 
     * 
     * @return 
     */  
    private static void build() {  
        try {  
            //特别注意：如果cluster 起了名字，需要在连接时指定名字，否则验证客户端连接的不是默认集群elasticsearch，会忽略，则无法找到节点  
            Settings settings = Settings.settingsBuilder()  
                    .put("cluster.name", "elasticsearch").build();
//                    .put("client.transport.ignore_cluster_name", true).build(); // 忽略集群名字验证, 打开后集群名字不对也能连接上
            client = TransportClient.builder().settings(settings).build()  
                    .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName('localhost'), 9300));  
 
        } catch (UnknownHostException e) {  
            throw new RuntimeException(e);  
        }  
    }  
  
}

impl类

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.count.CountResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.sort.SortOrder;

import com.gky.common.constant.ElasticSearchIndexTypeConstant.IndexType;
import com.gky.common.util.GsonHolder;


@SuppressWarnings("deprecation")
public class ElasticSearchTcpDaoImpl{
      //TCP连接客户端：  
    private  TransportClient client = null;  
  
    public ElasticSearchTcpDaoImpl(TransportClient client) {  
        this.client = client;  
    }  
    public TransportClient getClient() {  
        return client;
    }   

    public boolean careateIndex(String Mapperjson, IndexType indexType) {
        CreateIndexResponse createIndexResponse = client.admin().indices().prepareCreate(indexType.INDEX()).addMapping(indexType.INDEX(), Mapperjson).get(); 
        return createIndexResponse.isAcknowledged();
    }
    
    public boolean insert(Object doc,Long id,IndexType indexType) {
        String json = GsonHolder.gson.toJson(doc);  
        IndexResponse response = client.prepareIndex(indexType.INDEX(), indexType.TYPE(), String.valueOf(id)).setSource(json).get();  
        return response.isCreated();  
    }
    
    public boolean update(Object doc,Long oid,IndexType indexType) {
        String json = GsonHolder.gson.toJson(doc);  
          
        UpdateResponse response = client.prepareUpdate(indexType.INDEX(), indexType.TYPE(), String.valueOf(oid))  
                .setDoc(json)  
                .get();  
        
        return !response.isCreated();  
    }

    
    public boolean delete(long id,IndexType indexType) {
        DeleteResponse response = client.prepareDelete(indexType.INDEX(), indexType.TYPE(), String.valueOf(id)).get();  
        
        return response.isFound(); 
    }

    
    public Object searchById(Class<?> cls, long id,IndexType indexType) {
        GetResponse response = client.prepareGet(indexType.INDEX(), indexType.TYPE(), String.valueOf(id)).get();  
        if (response.isExists()) {  
            String json = response.getSourceAsString();  
            return Gson.gson.fromJson(json, cls);  
        }  
        return null; 
    }
    
    public List<Object> searchByUserId(Class<?> cls, long id,IndexType indexType, Integer pageStart, Integer pageSize) {
        QueryBuilder filter = new BoolQueryBuilder()  
        .must(QueryBuilders.termQuery("modifiedId", id)); 
        SearchResponse response = client.prepareSearch(indexType.INDEX())
                .setTypes(indexType.TYPE())
                .setQuery(filter)
                .setFrom(pageStart)
                .addSort("addTime", SortOrder.DESC) 
                .setSize(pageSize)
                .execute()
                .actionGet();  
        SearchHit[] hits = response.getHits().getHits();  
        List<Object> objs = new ArrayList<>();
        for (SearchHit hit : hits) {  
            Object obj= GsonHolder.gson.fromJson(hit.getSourceAsString(), cls);
            objs.add(obj);  
        } 
        return objs; 
    }
    
    /**
     * 全查
     */
    public List<Object> searchAll(Class<?> cls,IndexType indexType, Integer pageStart, Integer pageSize,String start,String end,String model,String makeObject,String modifiedName) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if(indexType.name().equals("LOGS")){
            if (StringUtils.isNotBlank(model)) {
                //通配符查询
                boolQueryBuilder.must(QueryBuilders.wildcardQuery("model", model)); 
            }
            if (StringUtils.isNotBlank(makeObject)) {
                //查询解析查询字符串
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(makeObject).field("content"));
            }
            if (StringUtils.isNotBlank(modifiedName)) {
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(modifiedName).field("modifiedName"));
            }
        }else{
            if (StringUtils.isNotBlank(start)) {
                //范围内查询
                boolQueryBuilder.must(QueryBuilders.rangeQuery("addTime").format(start)); 
            }
            if (StringUtils.isNotBlank(end)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery("addTime").to(end)); 
            }
            if (StringUtils.isNotBlank(model)) {
                //通配符查询
                boolQueryBuilder.must(QueryBuilders.wildcardQuery("model", model)); 
            }
            if (StringUtils.isNotBlank(makeObject)) {
                //查询解析查询字符串
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(makeObject).field("makeObject"));
            }
        }
        SearchResponse response = client.prepareSearch(indexType.INDEX())
                .setTypes(indexType.TYPE())
                //.setQuery(QueryBuilders.matchAllQuery())
                //.addSort(SortBuilders.fieldSort("addTime").order(SortOrder.DESC))
                .addSort("addTime", SortOrder.DESC) 
                .setFrom(pageStart)
                .setSize(pageSize)
                .setQuery(boolQueryBuilder)
                .execute()
                .actionGet();
        
        SearchHit[] hits = response.getHits().getHits();  
        List<Object> objs = new ArrayList<>();
        for (SearchHit hit : hits) {  
            Object obj= Gson.gson.fromJson(hit.getSourceAsString(), cls);
            objs.add(obj);  
        } 
        return objs; 
    }
    public List<Object> searchAll(Class<?> cls,IndexType indexType, Integer pageStart, Integer pageSize, String mode) {
        QueryBuilder filter = new BoolQueryBuilder()
        .must(QueryBuilders.termQuery("searchMode", mode)); 
        
        SearchResponse response = client.prepareSearch(indexType.INDEX())
                .setTypes(indexType.TYPE())
                //.setQuery(QueryBuilders.matchAllQuery())
                .setQuery(filter)
                //.addSort(SortBuilders.fieldSort("addTime").order(SortOrder.DESC))
                .addSort("addTime", SortOrder.DESC) 
                .setFrom(pageStart)
                .setSize(pageSize)
                .execute()
                .actionGet();  
        SearchHit[] hits = response.getHits().getHits();  
        List<Object> objs = new ArrayList<>();
        for (SearchHit hit : hits) {  
            Object obj= Gson.gson.fromJson(hit.getSourceAsString(), cls);
            objs.add(obj);  
        } 
        return objs; 
    }
    public List<Object> searchAll(Class<?> cls,IndexType indexType, Integer pageStart, Integer pageSize, String mode,Object modifierId) {
        QueryBuilder filter = new BoolQueryBuilder()
        .must(QueryBuilders.termQuery("searchMode", mode)) 
        .must(QueryBuilders.termQuery("modifierId", modifierId)); 
        SearchResponse response = client.prepareSearch(indexType.INDEX())
                .setTypes(indexType.TYPE())
                //.setQuery(QueryBuilders.matchAllQuery())
                .setQuery(filter)
                //.addSort(SortBuilders.fieldSort("addTime").order(SortOrder.DESC))
                .addSort("addTime", SortOrder.DESC) 
                .setFrom(pageStart)
                .setSize(pageSize)
                .execute()
                .actionGet();  
        SearchHit[] hits = response.getHits().getHits();  
        List<Object> objs = new ArrayList<>();
        for (SearchHit hit : hits) {  
            Object obj= Gson.gson.fromJson(hit.getSourceAsString(), cls);
            objs.add(obj);  
        } 
        return objs; 
    }
    
    /**
     * total
     */
    public Integer getTotal(IndexType indexType) {
        CountResponse countResponse = client.prepareCount(indexType.INDEX()).setTypes(indexType.TYPE()).get();
        Long logt=countResponse.getCount();
        return logt.intValue();
    }
    public Integer getTotal(IndexType indexType,Long oid) {
        QueryBuilder filter = new BoolQueryBuilder()
        .must(QueryBuilders.termQuery("modifiedId", oid)); 
        CountResponse countResponse = client.prepareCount(indexType.INDEX()).setTypes(indexType.TYPE()).setQuery(filter).get();
        Long logt=countResponse.getCount();
        return logt.intValue();
    }
    public Integer getTotal(IndexType indexType,String start,String end,String model,String makeObject,String modifiedName) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if(indexType.name().equals("LOG")){
            if (StringUtils.isNotBlank(model)) {
                boolQueryBuilder.must(QueryBuilders.wildcardQuery("modifiyMode", model)); 
            }
            if (StringUtils.isNotBlank(makeObject)) {
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(makeObject).field("content"));
            }
            if (StringUtils.isNotBlank(modifiedName)) {
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(modifiedName).field("modifiedName"));
            }
        }else{
            if (StringUtils.isNotBlank(start)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery("addTime").format(start)); 
            }
            if (StringUtils.isNotBlank(end)) {
                boolQueryBuilder.must(QueryBuilders.rangeQuery("addTime").to(end)); 
            }
            if (StringUtils.isNotBlank(model)) {
                boolQueryBuilder.must(QueryBuilders.wildcardQuery("model", model)); 
            }
            if (StringUtils.isNotBlank(makeObject)) {
                boolQueryBuilder.must(QueryBuilders.queryStringQuery(makeObject).field("makeObject"));
            }
        }
        
        CountResponse countResponse = client.prepareCount(indexType.INDEX()).setTypes(indexType.TYPE()).setQuery(boolQueryBuilder).get();
        Long logt=countResponse.getCount();
        return logt.intValue();
    }

}

Gson类

public class Gson {  
    public static Gson gson;  
  
    public static JsonParser jsonParser;  
  
    static {  
        gson = new GsonBuilder()  
                .setDateFormat("yyyy-MM-dd HH:mm:ss")  
                .create();  
  
        jsonParser = new JsonParser();  
    }  
  
  
    public static JsonElement getTopLevelElement(String json, String fieldName) {  
        JsonObject jsonObject = GsonHolder.jsonParser.parse(json).getAsJsonObject();  
        return jsonObject.get(fieldName);  
    }  
}

转载于:https://www.cnblogs.com/shuiqian/p/11118770.html