Java 操作Elasticsearch Demo

最新推荐文章于 2023-02-17 19:55:51 发布
最新推荐文章于 2023-02-17 19:55:51 发布
阅读量378 收藏 1
点赞数
分类专栏： elasticsearch 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45012575/article/details/102897985
版权
环境：

安装elasticsearch-6.2.4
安装kibana-6.2.4
安装ik分词器并将ik分词器解压到Elasticsearch目录的plugins目录中

配置运行：

第一步：进入Elasticsearch安装目录下的config目录，修改elasticsearch.yml文件.在文件的末尾加入以下代码：

http.cors.enabled: true 
http.cors.allow-origin: "*"
node.master: true
node.data: true

然后去掉network.host: 192.168.0.1的注释符号（#）并改为network.host: 0.0.0.0
去掉http.port的注释符号（#）
在这里插入图片描述
去掉cluster.name，node.name的注释符号（#）
在这里插入图片描述

启动elasticsearch-6.2.4和kibana-6.2.4。

构建maven项目
  • 1.pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.blj</groupId>
    <artifactId>elasicsearch-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>


</project>
  • 2.创建测试类
package com.blj.test;

import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetRequestBuilder;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.mapper.RangeFieldMapper;
import org.elasticsearch.index.query.*;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.filter.Filter;
import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.filter.Filters;
import org.elasticsearch.search.aggregations.bucket.filter.FiltersAggregator;
import org.elasticsearch.search.aggregations.bucket.range.Range;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.aggregations.metrics.cardinality.Cardinality;
import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.max.Max;
import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.min.Min;
import org.elasticsearch.search.aggregations.metrics.min.MinAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.sum.Sum;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.Test;

import javax.management.Query;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Map;
import java.util.Set;

/**
 * es Demo
 *
 * @author BaiLiJun on 2019/11/3 0003
 */
public class EsDemo {

    /**
     * Get 查询
     */
    @Test
    public void testGetQuery() throws UnknownHostException {
        TransportClient client = getClient();
        //数据查询
        GetResponse response = client.prepareGet("test_index", "test_type", "25")
                .execute().actionGet();
        //得到查询的数据
        System.out.println("response.getSourceAsString() = " + response.getSourceAsString());

        client.close();
    }

    private TransportClient getClient() throws UnknownHostException {
        //指定es集群
        Settings settings = Settings.builder().put("cluster.name", "my-application").build();
        //创建es客户端
        return new PreBuiltTransportClient(settings).addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
    }


    /*
    *添加文档
    *"{"+
    "\"id\":\"1\"," +
    "\ "title\":\ "Java设计模式之装饰模式\"," +
    "\ "content\":\ "在不必改变原类文件和使用继承的情况下，动态地扩展-一个对象的功能。\"," +
    "\ "postdate\":\"2019-11-03\","+
    "\"ur1\":\"csdn.net/ 79239072\"" +
    "}"
    */
    @Test
    public void testAddDoc() throws Exception {
        TransportClient client = getClient();
        //文档内容
        XContentBuilder doc = XContentFactory.jsonBuilder().startObject()
                .field("id", "1")
                .field("title", "Java设计模式之装饰模式")
                .field("content", "在不必改变原类文件和使用继承的情况下，动态地扩展-一个对象的功能")
                .field("postdate", "2019-11-03")
                .field("url", "csdn.net/79239072")
                .endObject();
        //添加文档
        IndexResponse response = client.prepareIndex("index1", "blog", "10")
                .setSource(doc).get();
        System.out.println("response.status() = " + response.status());
    }


    /**
     * 删除文档
     */
    @Test
    public void testDelete() throws Exception {
        TransportClient client = getClient();
        DeleteResponse response = client.prepareDelete("index1", "blog", "10").get();
        System.out.println("response.status() = " + response.status());

    }


    /**
     * 更新文档(局部更新)
     */
    @Test
    public void testUpdate() throws Exception {
        TransportClient client = getClient();
        UpdateRequest request = new UpdateRequest();
        request.index("index1").type("blog").id("10").doc(
                XContentFactory.jsonBuilder().startObject()
                        .field("title", "单例模式")
                        .field("postdate", "2019-11-05")
                        .endObject()
        );
        UpdateResponse response = client.update(request).get();
        System.out.println("response.status() = " + response.status());
    }

    /**
     * upset 更新操作:不存在就创建，存在就更新
     */
    @Test
    public void testUpset() throws Exception {
        TransportClient client = getClient();
        IndexRequest request1 = new IndexRequest("index1", "blog", "8")
                .source(
                        XContentFactory.jsonBuilder().startObject()
                                .field("id", "2")
                                .field("title", "工厂模式")
                                .field("content", "静态工厂，实例工厂")
                                .field("postdate", "2019-11-05")
                                .field("url", "csdn.net/79239072")
                                .endObject()
                );

        UpdateRequest request2 = new UpdateRequest("index1", "blog", "8").doc(
                XContentFactory.jsonBuilder().startObject()
                        .field("title", "设计模式")
                        .endObject()
        ).upsert(request1);

        UpdateResponse response = client.update(request2).get();
        System.out.println("response.status() = " + response.status());
    }

    /**
     * mget用法:批量查询
     */
    @Test
    public void testMultiGet() throws Exception {
        TransportClient client = getClient();
        MultiGetResponse response = client.prepareMultiGet()
                .add("index1", "blog", "8", "10")
                .add("test_index", "test_type", "22", "24")
                .get();
        for (MultiGetItemResponse itemResponse : response) {
            GetResponse response1 = itemResponse.getResponse();
            if (response1 != null && response1.isExists()) {
                System.out.println("response1.getSourceAsString() = " + response1.getSourceAsString());
            }
        }
    }

    /**
     * bulk 批量增删改操作
     */
    @Test
    public void testBulk() throws Exception {
        TransportClient client = getClient();
        BulkRequestBuilder requestBuilder = client.prepareBulk();
        requestBuilder.add(client.prepareIndex("index1", "blog", "9").setSource(
                XContentFactory.jsonBuilder().startObject()
                        .field("id", "3")
                        .field("title", "bulk 批量增demo1")
                        .field("content", "bulk 批量增demo1")
                        .field("postdate", "2019-11-05")
                        .field("url", "csdn.net/79239072")
                        .endObject()
        ));

        requestBuilder.add(client.prepareIndex("index1", "blog", "7").setSource(
                XContentFactory.jsonBuilder().startObject()
                        .field("id", "4")
                        .field("title", "bulk 批量增demo2")
                        .field("content", "bulk 批量增demo2")
                        .field("postdate", "2019-11-05")
                        .field("url", "csdn.net/79239072")
                        .endObject()
        ));

        BulkResponse response = requestBuilder.get();
        if (response.hasFailures()) {
            System.out.println("失败");
        } else {
            System.out.println(" response.status() = " + response.status());

        }


    }


    /**
     * 查询删除
     */
    @Test
    public void testDeleteByQuery() throws Exception {
        TransportClient client = this.getClient();
        BulkByScrollResponse response = DeleteByQueryAction.INSTANCE
                .newRequestBuilder(client)
                .filter(QueryBuilders.matchQuery("title", "模式"))
                .source("index1").get();
        long counts = response.getDeleted();
        System.out.println("counts = " + counts);
    }

    /**
     * 查询所有
     */
    @Test
    public void testMatchAllQuery() throws Exception {
        TransportClient client = getClient();
        MatchAllQueryBuilder matchAllQuery = QueryBuilders.matchAllQuery();
        SearchResponse response = client.prepareSearch("index1", "test_index").setQuery(matchAllQuery)
                .setSize(3).get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + " = " + map.get(key));
            }
        }
    }

    /**
     * match query
     */
    @Test
    public void testMatchQuery() throws Exception {
        TransportClient client = getClient();
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("test_field", "hello");
        SearchResponse response = client.prepareSearch("test_index", "index1").setQuery(matchQuery)
                .setSize(3).get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "  = " + map.get(key));
            }
        }
    }

    /**
     * multiMatchQuery 一个查询文本在多个字段中匹配，其中一个字段中有则返回
     */
    @Test
    public void testMultiMatchQuery() throws Exception {
        TransportClient client = getClient();
        MultiMatchQueryBuilder multiMatchQuery = QueryBuilders.multiMatchQuery("批量", "title", "content");
        SearchResponse response = client.prepareSearch("index1").setQuery(multiMatchQuery).setSize(3).get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "    =" + map.get(key));
            }
        }
    }


    /**
     * term query
     * term是代表完全匹配，即不进行分词器分析，文档中必须包含整个搜索的词汇
     */
    @Test
    public void testTermQuery() throws Exception {
        TransportClient client = getClient();
        TermQueryBuilder termQuery = QueryBuilders.termQuery("name", "jack");
        SearchResponse response = client.prepareSearch("test_index", "company")
                .setQuery(termQuery).setSize(3).get();

        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "    =" + map.get(key));
            }
        }
    }

    /**
     * terms query 多个词查询
     */
    @Test
    public void testTermsQuery() throws Exception {
        TransportClient client = getClient();
        TermsQueryBuilder termsQuery = QueryBuilders.termsQuery("name", "jack", "tom");
        SearchResponse response = client.prepareSearch("test_index", "company")
                .setQuery(termsQuery).setSize(3).get();

        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "= " + map.get(key));
            }
        }
    }

    /**
     * 各种查询
     */
    @Test
    public void testQuerys() throws Exception {
        TransportClient client = getClient();
        //range查询
        // RangeQueryBuilder builder = QueryBuilders.rangeQuery("join_work").from("2019-09-01").to("2019-11-7").format("yyyy-MM-dd");

        //prefix 查询
        //QueryBuilder builder = QueryBuilders.prefixQuery("name","zhao");

        //ids 查询
        // QueryBuilder builder = QueryBuilders.idsQuery().addIds("1","2","3");

        //wildcard 查询:通配符查询
        //QueryBuilder builder = QueryBuilders.wildcardQuery("name","zhao*");

        //type 查询
        //QueryBuilder builder = QueryBuilders.typeQuery("blog");

        //fuzzy 查询: 模糊查询
        QueryBuilder builder = QueryBuilders.fuzzyQuery("name", "jaek");

        SearchResponse response = client.prepareSearch("test_index", "company", "index1")
                .setQuery(builder).setSize(3)
                .get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + " = " + map.get(key));
            }
        }

    }


    /**
     * 聚合查询
     */
    @Test
    public void testAgg() throws Exception {
        TransportClient client = getClient();

//       AggregationBuilder agg = AggregationBuilders.max("aggMax").field("age");
//        SearchResponse response = client.prepareSearch("test_index", "company", "index1")
//                .addAggregation(agg).get();
//        Max max = response.getAggregations().get("aggMax");
//        System.out.println("max = " + max.getValue());

//        AggregationBuilder agg = AggregationBuilders.min("aggMin").field("age");
//        SearchResponse response = client.prepareSearch("test_index", "company", "index1").addAggregation(agg).get();
//        Min min = response.getAggregations().get("aggMin");
//        System.out.println("min.getValue() = " + min.getValue());

//        AggregationBuilder agg = AggregationBuilders.avg("aggAvg").field("age");
//        SearchResponse response = client.prepareSearch("test_index", "company", "index1").addAggregation(agg).get();
//        Avg avg = response.getAggregations().get("aggAvg");
//        System.out.println("avg = " + avg.getValue());

//        AggregationBuilder agg = AggregationBuilders.sum("aggSum").field("age");
//        SearchResponse response = client.prepareSearch("test_index", "company", "index1").addAggregation(agg).get();
//        Sum sum = response.getAggregations().get("aggSum");
//        System.out.println("sum = " + sum.getValue());

        //基数：即，如果有4个值，3个值不重复，则返回3
        AggregationBuilder agg = AggregationBuilders.cardinality("aggCardinality").field("age");
        SearchResponse response = client.prepareSearch("index1", "company").addAggregation(agg).get();
        Cardinality cardinality = response.getAggregations().get("aggCardinality");
        System.out.println("cardinality = " + cardinality.getValueAsString());
    }


    /**
     * queryString
     */
    @Test
    public void testQueryString() throws Exception {
        TransportClient client = getClient();
        //CommonTermsQueryBuilder builder = QueryBuilders.commonTermsQuery("name", "jack");

        //  +:必须包含  -：必须不能包含 queryStringQuery查询必须完全满足才返回结果
        //  QueryBuilder builder =QueryBuilders.queryStringQuery("+jiangsu -wuxi");

        //simpleQueryStringQuery 只需要满足其中一个条件就可以返回
        QueryBuilder builder = QueryBuilders.simpleQueryStringQuery("+jiangsu -wuxi");
        SearchResponse response = client.prepareSearch("index1", "company").setQuery(builder).setSize(3).get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + " = " + map.get(key));
            }
        }
    }


    /**
     * 组合查询
     */
    @Test
    public void testCombinationQuery() throws Exception {
        TransportClient client = getClient();
//        QueryBuilder builder = QueryBuilders.boolQuery()
//                .must(QueryBuilders.prefixQuery("name", "zhao"))
//                .mustNot(QueryBuilders.matchQuery("adress", "shanghai"))
//                .should(QueryBuilders.matchQuery("adress", "China"))
//                .filter(QueryBuilders.rangeQuery("join_work").gte("2019-09-01").format("yyyy-MM-dd"));


        //constantScoreQuery 不计算相关度分数
        QueryBuilder builder =QueryBuilders.constantScoreQuery(QueryBuilders.wildcardQuery("name","zhao*"));
        SearchResponse response = client.prepareSearch("index1", "company").setQuery(builder)
                .setSize(3).get();
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("hit.getSourceAsString() = " + hit.getSourceAsString());
        }
    }

    /**
     * 分组聚合
     */
    @Test
    public void testTermsAgg() throws UnknownHostException {
        TransportClient client = getClient();
       AggregationBuilder builder = AggregationBuilders.terms("terms").field("age");
        SearchResponse response = client.prepareSearch("company")
                .addAggregation(builder).execute().actionGet();
        Terms terms = response.getAggregations().get("terms");
        for (Terms.Bucket entry : terms.getBuckets()) {
            System.out.println(entry.getKey()+":"+entry.getDocCount());
        }
                
    }

    /**
     * Filter 聚合
     */
    @Test
    public void testFilterAgg() throws UnknownHostException {
        TransportClient client = getClient();
      QueryBuilder query = QueryBuilders.termQuery("age", 26);
       AggregationBuilder agg = AggregationBuilders.filter("filter", query);
        SearchResponse response = client.prepareSearch("company").addAggregation(agg).execute().actionGet();
        Filter filter = response.getAggregations().get("filter");
        System.out.println("filter.getDocCount() = "+filter.getDocCount());
    }

    /**
     * Filters 聚合
     */
    @Test
    public void testFiltersAgg() throws UnknownHostException {
        TransportClient client = getClient();
        AggregationBuilder agg = AggregationBuilders.filters("filters",
                new FiltersAggregator.KeyedFilter("26",QueryBuilders.termsQuery("age","26")),
                new FiltersAggregator.KeyedFilter("27",QueryBuilders.termsQuery("age","27"))
                );
        SearchResponse response = client.prepareSearch("company").addAggregation(agg).execute().actionGet();
        Filters filters = response.getAggregations().get("filters");
        for (Filters.Bucket entry : filters.getBuckets()) {
            System.out.println(entry.getKey()+":"+entry.getDocCount());
        }
    }

    /**
     * Range 聚合
     */
    @Test
    public void testRangeAgg() throws UnknownHostException {
        TransportClient client = getClient();
        AggregationBuilder agg = AggregationBuilders.range("range")
                .field("age")
                .addUnboundedTo(30)
                .addRange(25,30)
                .addUnboundedFrom(25);
        SearchResponse response = client.prepareSearch("company").addAggregation(agg).execute().actionGet();
        Range range = response.getAggregations().get("range");
        for (Range.Bucket entry : range.getBuckets()) {
            System.out.println(entry.getKey()+":"+entry.getDocCount());
        }
    }

    /**
     * missing 聚合:统计null值的字段有多少个
     */
    @Test
    public void testMissingAgg() throws UnknownHostException {
        TransportClient client = getClient();
        AggregationBuilder agg = AggregationBuilders.missing("missing").field("join_work");
        SearchResponse response = client.prepareSearch("company").addAggregation(agg).execute().actionGet();
        Aggregation missing = response.getAggregations().get("missing");
        System.out.println("missing.toString() = " + missing.toString());

    }


}
白礼军
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES客户端Demo（2021-09-01）
weixin_40803176的博客
09-06 262
工作中接触到Elasticsearch，需要使用JAVA客户端获取ES保存的数据，本文记录ES客户端Demo和工作中用到的查询方法
elasticSearch的操作demo
02-19
这个“elasticSearch的操作demo”旨在展示如何在Java环境中与Elasticsearch进行交互。 首先，我们关注`ElasticsearchConfig.java`文件。这个文件通常包含了Elasticsearch的配置信息，如节点地址、端口、集群名等。...
Elasticsearch入门Demo（一）
小草的博客
04-04 6400
1.创建一个Maven工程，在pom.xml中添加如下代码：&lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://...
ElasticSearch javaAPI demo示例
热门推荐
u013473512的博客
09-28 4万+
一.数据实体： ID：自增主键 ID：ID值 VALUE_DAY：该机器当天的值 GROUPNAME：组名 TYPE_MACHINE：机器类型 DATE：日期 TYPE：类型 二.Java代码： 1.创建客户端： package elasticsearch.util; import java.net.InetAddress; import org.elastic
ElasticSearch的java高级客户端demo
qq_26896085的博客
02-16 349
依赖 <dependencies> <!-- 低级客户端--> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest...
ElasticSearch入门小demo
MAX_xiaowu的博客
12-14 374
1. 创建Maven工程，引入ElasticSearch坐标 导入坐标 <?xml version="1.0" encoding="UTF-8"?> 4.0.0 <groupId>com.itheima</groupId> <artifactId>elasticsearch_demo</artifactId> <version...
java操作elasticsearch5.x的demo
08-08
Java操作Elasticsearch 5.x的Demo详解 在大数据时代，Elasticsearch作为一个高效、可扩展的全文搜索引擎，被广泛应用于日志分析、实时监控、数据挖掘等领域。本篇文章将详细解析如何使用Java API来操作Elastic...
elasticsearch-java-demo
12-01
"elasticsearch-java-demo"这个项目很可能是展示如何在 Java 中使用 Spring Boot 整合 Elasticsearch 的示例。它可能包含了初始化数据、执行查询、插入和更新数据的示例代码。这个项目对于学习和理解如何在实际应用...
ElasticSearch Java开发Demo.zip
04-05
ElasticSearch Java：ransportClient将会在后面的版本中弃用，因此不推荐后续使用；而Jest由于是社区维护，所以更新有一定延迟，目前最新版对接ES6.3.1，近一个月只有四个issue，说明整体活跃度较低，因此也不推荐...
ElasticSearch java开发Demo(5.1.5)_Javaelasticsearch_ES使用java开发_ela
10-03
在Java环境中，我们可以使用官方提供的Java API来与Elasticsearch进行交互，实现数据的索引、查询、更新和删除等操作。 **一、Elasticsearch Java API** 1. **安装与配置**: 首先，你需要在项目中引入Elastic...
elasticsearch v6.3.2 演示demo
08-28
需elasticsearch v6.3.2配合使用（elasticsearch 安装配置请参考网络教程）
elasticsearchJavaDemo
08-21
java操作elasticsearch 增删改查小练习,大家可以下载下来看看!
elasticsearch demo示例 源码程序
09-27
ElasticSearch的基本示例，使用JavaAPI制作的demo，能够实现ElasticSearch的基本功能，内含Google的protobuf消息方法方式的基本示例，均已测试通过。
es-demo 使用es-java-api 开箱即用
10-08
使用spring-cloud框架搭建，集成esjavaapi，直接打开idea从es-pom项目中导入pom文件即可，修改application.properties文件中你的es服务地址即可，增删改查均可使用
Java操作es的问题与案例 demo
fct2001140269的博客
07-30 1254
Java操作es的问题与案例 demo 问题1：No Log4j 2 configuration file found ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmat...
java使用elasticsearch的ik分词器，代码案例
weixin_35757191的博客
02-17 372
使用IK分词器的Java代码案例如下： // 创建IK分词器 Analyzer analyzer = new IKAnalyzer(); // 获取TokenStream TokenStream tokenStream = analyzer.tokenStream("content", new StringReader("欢迎使用IK Analyzer")); // 获取词元位置属性 Off...
java项目集成ES
qq_33101025的博客
05-19 1265
点击跳转https://blog.csdn.net/kungFuApe/article/details/118546067
elasticsearch__1__java操作之连接es,创建Mapping,保存数据
2.wa
07-08 1万+
package com.elasticsearch; import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; import org.elasticsearch.action.bulk.BulkRequestBuilder; import org.elasticsearch.action.bul
ElasticSearch之——Java操作ES实例（基于ES-2.3.0）
冰河的专栏
12-09 9776
转载请注明出处：http://blog.csdn.net/l1028386804/article/details/78758691 今天，我们就来看看如何利用Java API来操作ES的数据，这里不讲理论的东西了，大家可以参看其他资料了解，这里直接给出实例代码。好了不多说了，我们直接上代码： 1、获取client句柄   /** * 获取client句柄 * @return * @...
写个Java使用elasticsearch搜索的demo
最新发布
05-25
好的，以下是一个简单的 Java demo，使用 Elasticsearch 进行搜索： ```java import java.io.IOException; import java.util.HashMap; import java.util.Map; import org.apache.http.HttpHost; import org....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值