elasticsearch Java API

最新推荐文章于 2024-08-05 16:36:21 发布
最新推荐文章于 2024-08-05 16:36:21 发布
阅读量403 收藏
点赞数 1
分类专栏： elk 文章标签： elasticsearch Java API elasticsearch API SearchRequestBuilder 备份 AggregationBuilder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wutongyuWxc/article/details/79230997
版权

1 项目启动时，初始化连接es

private static Logger log = LoggerFactory.getLogger(ElasticsearchUtil.class);
private static TransportClient client;
private static Settings esSettings;
public static void init() {
        //设置ES实例的名称.put("client.transport.sniff", true) //自动嗅探整个集群的状态，把集群中其他ES节点的ip添加到本地的客户端列表中
        esSettings = Settings.builder().put("transport.type","netty3").put("http.type", "netty3").put("cluster.name", "elasticsearch").build();
        try {
            client = new PreBuiltTransportClient(esSettings);//初始化client较老版本发生了变化，此方法有几个重载方法，初始化插件等。
            //此步骤添加IP，至少一个，其实一个就够了，因为添加了自动嗅探配置
            String es_Ip = PropertiesUtil.getProValueByKey("elk", "es_Ip");
            String es_port = PropertiesUtil.getProValueByKey("elk", "es_port");
            client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(es_Ip), Integer.parseInt(es_port)));
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        log.error("elasticsearch 连接成功");
}

2 判断当前索引是否存在


   public static boolean isExistsIndex(String indexName){
        IndicesExistsResponse response = client.admin().indices().exists(
                new IndicesExistsRequest().indices(new String[]{indexName})).actionGet();
        return response.isExists();
    }

3 单个保存，创建index并保存数据，把其中的文档转化为json的格式存储


public static void createIndex(Object info, String index, String type, String id) throws ElasticsearchException, IOException {
        client.prepareIndex(index, type, id).setSource(JsonUtil.toJson(info)).setRefreshPolicy("true").execute().actionGet();
}

4 批量保存


public static void batchInsertInfo(List<Map<String,Object>> logInfoMap){
        BulkRequestBuilder bulkRequest=client.prepareBulk();
        boolean flag=false;
        for(int i=0,len=logInfoMap.size();i<len;i++){
            Map<String,Object> map=logInfoMap.get(i);
            String index=map.get("index").toString();
            String id=map.get("uuid").toString();
            bulkRequest.add(client.prepareIndex(index,"syslog").setSource(map).setId(id));
            flag=true;
        }
        //判空处理
        if(flag){
            bulkRequest.execute().actionGet();
        }
    }

5 mapper索引，每个索引只能mapper一次，不能重复mapper


public static void createMapping( Class<?> object,String index, String type) throws ElasticsearchException,IOException {
        if(!isExistsIndex(index)){
            client.admin().indices().prepareCreate(index).execute().actionGet();
            XContentBuilder xcontentBuilder = jsonBuilder().startObject().startObject("properties");
            Field[] fields = object.getDeclaredFields();// 根据字段名来获取字段
            //反射获取字段
            for( Field field:fields ) {
                if(field.getType().toString().contains( "String" )){
                    xcontentBuilder.startObject(field.getName()).field("type", "keyword").field("index", "not_analyzed").endObject();
                }
            }
            xcontentBuilder.endObject().endObject();
            PutMappingRequest mappingRequest = Requests.putMappingRequest(index).type(type).source(xcontentBuilder);
            client.admin().indices().putMapping(mappingRequest).actionGet();
        }
}
//使用方法  ElasticsearchUtil.createMapping(LogInfo.class, index, "syslog");

6 根据索引、类型、id 获取es单条数据


public static GetResponse getOneInfo(String index, String type,String id) {
        return client.prepareGet(index, type,id).execute().actionGet();
}

7 单条删除 根据index、type、id删除执行文档


public static void delete(String index, String type, String id) {
        DeleteResponse deleteresponse = client.prepareDelete(index, type, id).execute().actionGet();
        //如果实时性要求高的话，需要强制刷新
        //deleteresponse.forcedRefresh()
}

8 批量删除


//参数格式 index_type_id
public static boolean batchDelete(List<String> index_type_idList) {
        try {
            if(CollectionUtils.isNotEmpty( index_type_idList )){
                BulkRequestBuilder bulkRequestBuilder = client.prepareBulk().setRefreshPolicy("true");
                for( String index_type_id:index_type_idList ) {
                    String[] arr=index_type_id.split( "_" );
                    DeleteRequestBuilder deleteRequestBuilder = client.prepareDelete(arr[0], arr[1], arr[2]);
                    bulkRequestBuilder.add( deleteRequestBuilder );
                }
                BulkResponse aa=bulkRequestBuilder.execute().actionGet();
                return !aa.hasFailures();
            }
        } catch( Exception e ) {
            e.printStackTrace();
        }
        return false;
}

9 删除索引及索引下的所有文档


public static void deleteIndex(String[] index) {
        client.admin().indices().prepareDelete(index).execute().actionGet();
}

10 获取所有索引


public static String[] getAllIndex() {
        ClusterStateResponse response = client.admin().cluster().prepareState().execute().actionGet();
        return response.getState().getMetaData().getConcreteAllIndices();
}

11 项目启动时，创建备份仓库


public static void createSnapshotRepository() {
        try {
            Settings settings =esSettings.builder().put("location", "/opt/data/backup/my_backup").build();
            PutRepositoryRequestBuilder putRepo = new PutRepositoryRequestBuilder(client.admin().cluster(), PutRepositoryAction.INSTANCE);
            putRepo.setName( ElasticsearchEnum.ES_REPOSITORYNAME).setType("fs").setSettings(settings).execute().actionGet();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

12 执行备份


//参数  仓库名；备份的索引；备份名称
public static void createSnapshot(String repositoryName,String[] index, String snapshot ) {
        CreateSnapshotRequestBuilder builder = new CreateSnapshotRequestBuilder(client.admin().cluster(), CreateSnapshotAction.INSTANCE);
        builder.setRepository(repositoryName).setIndices(index).setSnapshot(snapshot);
        builder.execute().actionGet();
}

13 恢复备份的索引及文档

//参数  仓库名称 ； 备份名称
public static void restoreSnapshot(String repositoryName, String snapshot) {
        List<String> indices = Lists.newArrayList();
        try {
            GetSnapshotsRequestBuilder builder = new GetSnapshotsRequestBuilder(client.admin().cluster(), GetSnapshotsAction.INSTANCE);
            builder.setRepository(repositoryName);
            builder.setSnapshots(snapshot);
            GetSnapshotsResponse getSnapshotsResponse = builder.execute().actionGet();
​
            //检查索引是否存在，如果是，请关闭它，然后再恢复。
            indices = getSnapshotsResponse.getSnapshots().get( 0 ).indices();
            CloseIndexRequestBuilder closeIndexRequestBuilder = new CloseIndexRequestBuilder(client.admin().indices(), CloseIndexAction.INSTANCE);
            closeIndexRequestBuilder.setIndices(indices.toArray(new String[indices.size()]));
            closeIndexRequestBuilder.execute().actionGet();
        } catch( Exception e ) {
            log.error( "索引不存在，无法关闭！"+ ToStringBuilder.reflectionToString( indices.toArray(new String[indices.size()]) ));
        }
​
        // 执行恢复索引操作
        RestoreSnapshotRequestBuilder restoreBuilder = new RestoreSnapshotRequestBuilder(client.admin().indices(), RestoreSnapshotAction.INSTANCE);
        restoreBuilder.setRepository(repositoryName).setSnapshot(snapshot);
        restoreBuilder.execute().actionGet();
    }

14 丰富的条件查询


public static  List<LogInfo> getAllLogInfo(String[] index,Criteria criteria) throws Exception {
        List<LogInfo> logInfoList = Lists.newArrayList();
       
        try {
            //es搜索，按照接收时间降序
            SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
            criteria.setCurrentPage( (criteria.getCurrentPage()+5)/6 );
            searchRequestBuilder.setFrom(((criteria.getCurrentPage()-1) * criteria.getPageSize())*6).setSize( 6*criteria.getPageSize()).addSort("receivedTime", SortOrder.DESC);
            Map<String, Object> condition = criteria.getCondition();
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            if( condition !=null && condition.size()>0){
                Iterator<Map.Entry<String,Object>> iterator = condition.entrySet().iterator();
                while( iterator.hasNext() ) {
                    Map.Entry<String,Object> entry = iterator.next();
                    if("logLevel".equals( entry.getKey() ) || "facility".equals( entry.getKey() )){
                        QueryBuilder queryBuilder = QueryBuilders.matchQuery( entry.getKey(),entry.getValue() );
                        boolQueryBuilder.must(queryBuilder); //且的关系，如果是或则用.should()
                    }else if("logSourceUuid".equals( entry.getKey() )){
                        String[] split = entry.getValue().toString().split( "_" );
                        BoolQueryBuilder boolQueryBuilderIp = QueryBuilders.boolQuery();
                        for( int i = 0; i < split.length; i++ ) {
                          //正则匹配  
                          QueryBuilder queryBuilder = QueryBuilders.wildcardQuery(entry.getKey(),"*"+split[i]+"*");
                            boolQueryBuilderIp.should(queryBuilder);
                        }
                        boolQueryBuilder.must(boolQueryBuilderIp);
                    }else if("receivedTime".equals( entry.getKey() )){
                        String start = entry.getValue().toString().split( "#" )[0].trim();
                        String end = entry.getValue().toString().split( "#" )[1].trim();
                        //通过时间过滤
                        QueryBuilder queryBuilder = QueryBuilders.rangeQuery(entry.getKey() ).from( start ).to( end );
                        boolQueryBuilder.must(queryBuilder);
                    }else if("rulelist".equals( entry.getKey() )){
                        List<StrategyRuleRel> strategyRuleRels = Lists.newArrayList();
                        List<Map<String,String>> values = ( List<Map<String,String>> )entry.getValue();
                        for( Map<String,String> maps:values ) {
                            StrategyRuleRel rule = JsonUtil.jsonToObject( JsonUtil.map2Json( maps ), StrategyRuleRel.class );
                            if (rule.getRuleType() == 1) {   //以XXX开始
                                if (rule.getRuleRelation() == 1) {
                                    PrefixQueryBuilder aa = QueryBuilders.prefixQuery(rule.getLogField(), rule.getContent());
                                    boolQueryBuilder.must(aa);
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.prefixQuery(rule.getLogField(), rule.getContent()));
                                }
                            } else if (rule.getRuleType() == 2) { //以XXX结束
                                if (rule.getRuleRelation() == 1) {
                                    boolQueryBuilder.must(QueryBuilders.wildcardQuery(rule.getLogField(), "*" + rule.getContent()));
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.wildcardQuery(rule.getLogField(), "*" + rule.getContent()));
                                }
                            } else if (rule.getRuleType() == 3) { //包含
                                if (rule.getRuleRelation() == 1) { boolQueryBuilder.must(QueryBuilders.wildcardQuery(rule.getLogField(), "*"+rule.getContent()+"*"));
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.wildcardQuery(rule.getLogField(), "*"+rule.getContent()+"*"));
                                }
                            }else if (rule.getRuleType() == 5) {  //正则表达式
                                if (rule.getRuleRelation() == 1) {
                                    boolQueryBuilder.must(QueryBuilders.regexpQuery(rule.getLogField(), rule.getContent()));
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.regexpQuery(rule.getLogField(), rule.getContent()));
                                }
                            } else if (rule.getRuleType() == 6) { //通配符
                                if (rule.getRuleRelation() == 1) {
                                    boolQueryBuilder.must(QueryBuilders.wildcardQuery(rule.getLogField(), rule.getContent()));
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.wildcardQuery(rule.getLogField(), rule.getContent()));
                                }
                            }else if (rule.getRuleType() == 7) { //等于
                                if (rule.getRuleRelation() == 1) {
                                    QueryBuilder queryBuilder = QueryBuilders.termQuery( rule.getLogField(),rule.getContent() );
                                    boolQueryBuilder.must(queryBuilder);
                                } else {
                                    boolQueryBuilder.should(QueryBuilders.wildcardQuery(rule.getLogField(), rule.getContent()));
                                }
                            }
                        }
                    }else {
                        QueryBuilder queryBuilder = QueryBuilders.wildcardQuery(entry.getKey(),"*"+entry.getValue().toString()+"*");
                        boolQueryBuilder.must(queryBuilder);
                    }
                }
            }
            searchRequestBuilder.setQuery(boolQueryBuilder);
            SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHists = hits.getHits();
            if (searchHists.length > 0) {
                for (SearchHit hit : searchHists) {
                    //解析对象
                    Map<String, Object> objectMap = hit.getSource();
                    Iterator<Map.Entry<String, Object>> iterator = objectMap.entrySet().iterator();
                    //组装对象
                    LogInfo logInfo = new LogInfo();
                    while( iterator.hasNext() ) {
                        Map.Entry<String, Object> entry = iterator.next();
                        Field field = LogInfo.class.getDeclaredField(entry.getKey());// 根据字段名来获取字段
                        Method method = LogInfo.class.getMethod( "set" + StringUtil.capitalize( entry.getKey() ),new Class[] { field.getType() } );
                        if(field.getType()==Integer.class){
                            method.invoke( logInfo, Integer.parseInt( entry.getValue().toString() ));
                        }else{
                            method.invoke( logInfo, entry.getValue().toString() );
                        }
                    }
                    logInfo.setIndex( hit.getIndex() );
                    logInfo.setType( hit.getType() );
                    logInfo.setId( hit.getId() );
                    logInfoList.add( logInfo );
                }
            }
        } catch(Exception e ) {
            e.printStackTrace();
        }
        return logInfoList;
    }
​

15 聚合查询【统计】


//参数：  查询涉及的索引；聚合的关键字段 ；开始时间； 结束时间
public static  SearchResponse countLogInfoForCondition(String[] index,String field,String startTime,String endTime) throws Exception {
        //去除不存在的索引，以免查询出错
        List<String> indexTemp = getExistIndex( index );
        if(CollectionUtils.isEmpty( indexTemp )){
            return null;
        }
        //聚合查询，取十条
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch((String[])indexTemp.toArray(new String[indexTemp.size()]));
        searchRequestBuilder.setFrom(0).setSize(10).addSort("receivedTime", SortOrder.DESC);
        if(field != null){
            AggregationBuilder aggregationBuilder = AggregationBuilders.terms( "aggregation" ).field( field );
            searchRequestBuilder.addAggregation( aggregationBuilder );
        }
        //统计时间段范围的日志信息
        if(startTime != null && endTime != null){
            searchRequestBuilder.setQuery( QueryBuilders.rangeQuery("receivedTime").from(startTime).to(endTime) ); 
        }
        SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
        return searchResponse;
}
//***************方法调用规则************************
SearchResponse searchResponse = ElasticsearchUtil.countLogInfoForCondition( index, "eventLevel", startTime, entTime);
if(searchResponse != null){
    List<SysConfig> sysConfigs = sysConfigService.getSysCnfListByType( 9 );
    Terms terms = searchResponse.getAggregations().get("aggregation");
    List<Terms.Bucket> buckets = terms.getBuckets();
    for(Terms.Bucket bucket:buckets){
        System.out.println(bucket.getKey()+"#"+bucket.getDocCount());
    }
}

更多官方API: https://www.elastic.co/guide/en/elasticsearch/reference

 

 

 

不会写诗的程序猿
关注
专栏目录
Elasticsearch的学习以及其JAVA API的使用
baidu_17353319的博客
11-21 2010
此文章主要整理Elasticsearch的实际使用中遇到的一些搜索技巧以及JAVA API的调用方法。后续会不断地补充。 目录 简单搜索 Match All Query Term Query Match Query Boolean Phrase和Phrase_prefix MultiMatch Query Wildcard Query Query String Query...
使用Java操作Elasticsearch(Elasticsearch的java api使用)
HiterCoder
10-21 550
1、Elasticsearch是基于Lucene开发的一个分布式全文检索框架，向Elasticsearch中存储和从Elasticsearch中查询，格式是json。 索引index，相当于数据库中的database。 类型type相当于数据库中的table。 主键id相当于数据库中记录的主键，是唯一的。 向Elasticsearch中存储数据，其实就是向es中的index下面的...
elasticsearch java api
09-10
elasticsearch java api，隔壁的30分比较老，基本上都用不了
elasticsearch JAVA API
Ocean_Point
08-24 457
elasticsearch  版本 6.3.0 Java API [6.4]    ##### 获取全部索引     import org.elasticsearch.client.Client;     import org.elasticsearch.client.transport.TransportClient;     import org.elasticsearch.comm...
elasticsearch的学习（二）：Java api操作elasticsearch
最新发布
weixin_45037073的博客
08-05 777
使用Java api操作elasticsearch。
ElasticSearch java api
海纳GIS专栏
07-26 121
pom.xml 增加依赖, 包含坐标转换api <!-- elasticsearch的客户端 --> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.9.0</version&gt.
ElasticSearch JAVA API
曾有樱花落海洋
03-04 1267
Java API pom.xml org.elasticsearch.client:elasticsearch-rest-client org.elasticsearch:elasticsearch &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.elasticsearch.client&amp;lt;/groupId&amp;gt; &amp;lt;a
ElasticSearch Java API 中文文档
01-04
标签《ES Java API 中文文档》强调了文档的内容属性，它属于ElasticSearch的一个重要组成部分，即用Java语言进行数据交互和操作的应用程序接口部分。 从部分内容中可以提取出以下知识点： 1. **Transport Client**...
基于Elasticsearch Java API的参考手册
04-29
**Elasticsearch Java API详解** Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，广泛应用于大数据领域的实时分析和信息检索。Java API是Elasticsearch官方提供的与Elasticsearch服务器进行交互的...
elasticsearch java api 离线文档
11-06
**Elasticsearch Java API 离线文档** Elasticsearch 是一个开源的、分布式、全文检索搜索引擎，广泛用于实时数据分析和大规模数据检索。Java API 是 Elasticsearch 提供的主要客户端接口之一，使得开发者能够方便...
ElasticSearch Java API
12-09
通过Java API操作ElasticSearch的应用实例，具体解析详情请参见博文：http://blog.csdn.net/l1028386804/article/details/78758691
ElasticSearch java API
03-27
ElasticSearch 官方 java API
Elasticsearch Java API
qq_42999037的博客
10-09 183
Elasticsearch 软件是由 Java 语言开发的，所以也可以通过 Java API 的方式对 Elasticsearch服务进行访问 1 创建 Maven 项目 修改 pom 文件，增加 Maven 依赖关系 <dependencies> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <v
elasticsearch基本操作之--java基本操作 api
weixin_34168880的博客
02-12 146
/**  * 系统环境: vm12 下的centos 7.2  * 当前安装版本: elasticsearch-2.4.0.tar.gz  */ 默认进行了elasticsearch安装和ik安装, 超时配置, 分页压力配置等 添加maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.elasticsearch&lt;/group...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值