Elasticsearch--客户端

这篇具有很好参考价值的文章主要介绍了Elasticsearch--客户端。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Es客户端

语言无关

Elasticsearch--客户端,elasticsearch

 java最常用的客户端是Java Client、Java Rest Client、Java Transport Client

Java Client

从es7.17开始,官方推出Java Client,并且将Java Rest Client标为Deprecated(过期)

要求jdk至少要jdk8

具体用法再看===》

Java Rest Client

 Java Rest Client分为:

Java Low level Rest Client

Java High level Rest Client

在es7.15的时候过期的

RestClient 是线程安全的,RestClient使用 Elasticsearch 的 HTTP 服务,默认为9200端口,这一点和transport client不同。

Java Low level Rest Client

之所以称为低级客户端,是因为它几乎没有帮助 Java 用户构建请求或解析响应。它处理请求的路径和查询字符串构造,但它将 JSON 请求和响应主体视为必须由用户处理的不透明字节数组。

特点
  • 与任何 Elasticsearch 版本兼容

    • ES 5.0.0只是发布第一个Java Low-level REST client时的ES版本(2016年),不代表其向前只兼容到5.0,Java Low-level REST client基于Apache HTTP 客户端,它允许使用 HTTP 与任何版本的 Elasticsearch 集群进行通信。

  • 最小化依赖

  • 跨所有可用节点的负载平衡

  • 在节点故障和特定响应代码的情况下进行故障转移

  • 连接失败惩罚(是否重试失败的节点取决于它连续失败的次数;失败的尝试越多,客户端在再次尝试同一节点之前等待的时间就越长)

  • 持久连接

  • 请求和响应的跟踪记录

  • 可选的集群节点自动发现(也称为嗅探)

Java High Level REST Client

Java 高级 REST 客户端在 Java 低级 REST 客户端之上运行。

它的主要目标是公开 API 特定的方法,接受请求对象作为参数并返回响应对象,以便请求编组和响应解组由客户端本身处理。

要求Elasticsearch版本为2.0或者更高。

maven

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>7.12.0</version>
</dependency>

 初始化

// 初始化
RestClient restClient = RestClient.builder(
    new HttpHost("localhost1", 9200, "http"),
    new HttpHost("localhost2", 9200, "http")).build();

// 资源释放
restClient.close();

简单用法 

    @Test
    @SneakyThrows
    public void createIndex() {

        //region 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        //endregion

        //region Request对象
        CreateIndexRequest request = new CreateIndexRequest("product2");
        //endregion

        //region 组装数据
        //region setting
        request.settings(Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 0)
        );
        //endregion

        //region mapping
//        request.mapping(
//                "{\n" +
//                        "  \"properties\": {\n" +
//                        "    \"message\": {\n" +
//                        "      \"type\": \"text\"\n" +
//                        "    }\n" +
//                        "  }\n" +
//                        "}",
//                XContentType.JSON);

        //region 还可以使用Map构建
//        Map<String, Object> message = new HashMap<>();
//        message.put("type", "text");
//        Map<String, Object> properties = new HashMap<>();
//        properties.put("message", message);
//        Map<String, Object> mapping = new HashMap<>();
//        mapping.put("properties", properties);
//        request.mapping(mapping);
        //endregion

        //region 使用XContentBuilder构建
//        XContentBuilder builder = XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.startObject("properties");
//            {
//                builder.startObject("message");
//                {
//                    builder.field("type", "text");
//                }
//                builder.endObject();
//            }
//            builder.endObject();
//        }
//        builder.endObject();
//        request.mapping(builder);
        //endregion

        //endregion


        //region 别名
        request.alias(new Alias("product_alias").filter(QueryBuilders.termQuery("name", "xiaomi")));
        //endregion
        request.timeout(TimeValue.timeValueMillis(2));
        //endregion


        // 同步
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        // 异步
        client.indices().createAsync(request, RequestOptions.DEFAULT, new ActionListener<CreateIndexResponse>() {
            @Override
            public void onResponse(CreateIndexResponse createIndexResponse) {

            }

            @Override
            public void onFailure(Exception e) {

            }
        });

        // 是否所有节点都已确认请求
        createIndexResponse.isAcknowledged();
        // 在超时之前是否为索引中的每个碎片启动所需数量的碎片副本
        createIndexResponse.isShardsAcknowledged();
        client.close();
    }

    @Test
    @SneakyThrows
    public void getIndex() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );

        GetIndexRequest request = new GetIndexRequest("product*");
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        String[] indices = response.getIndices();
        for (String indexName : indices) {
            System.out.println("index name:" + indexName);
        }

        client.close();
    }

    @Test
    @SneakyThrows
    public void delIndex() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        DeleteIndexRequest request = new DeleteIndexRequest("product2");
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        if (response.isAcknowledged()) {
            System.out.println("删除index成功!");
        } else {
            System.out.println("删除index失败!");
        }
        client.close();
    }

    @Test
    @SneakyThrows
    public void insertData() {
        //region 创建连接
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        //endregion

        //region 准备数据
        List<Product> list = service.list();
        //endregion

        //region 创建Request对象
        //插入数据,index不存在则自动根据匹配到的template创建。index没必要每天创建一个,如果是为了灵活管理,最低建议每月一个 yyyyMM。
        IndexRequest request = new IndexRequest("test_index");
        //endregion

        //region 组装数据
        Product product = list.get(0);
        Gson gson = new Gson();
        //最好不要自定义id 会影响插入速度。
        request.id(product.getId().toString());
        request.source(gson.toJson(product)
                , XContentType.JSON);
        //endregion

        //region 执行Index操作
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //endregion

        System.out.println(response);
        client.close();
    }

    @Test
    @SneakyThrows
    public void batchInsertData() {
        //region 创建连接
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        //endregion

        //region 创建Request对象
        //批量插入数据,更新和删除同理
        BulkRequest request = new BulkRequest("test_index");
        //endregion

        //region 组装数据
        Gson gson = new Gson();
        Product product = new Product();
        product.setPrice(3999.00);
        product.setDesc("xioami");
        for (int i = 0; i < 10; i++) {
            product.setName("name" + i);
            request.add(new IndexRequest()
                    .id(Integer.toString(i))
                    .source(gson.toJson(product)
                    , XContentType.JSON)
            );
        }
        //endregion

        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

        System.out.println("数量:" + response.getItems().length);
        client.close();
    }

    @Test
    @SneakyThrows
    public void getById() {
        //region 创建连接
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")));
        //endregion

        //region 创建Request对象
        //注意 这里查询使用的是别名。
        GetRequest request = new GetRequest("test_index", "6");
        //endregion

        //region 组装数据
        String[] includes = {"name", "price"};
        String[] excludes = {"desc"};
        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
        //只查询特定字段。如果需要查询所有字段则不设置该项。
        request.fetchSourceContext(fetchSourceContext);
        //endregion

        //region 响应数据
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //endregion

        System.out.println(response);
        client.close();

    }

    @Test
    public void delById() throws IOException {
        //region Description
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        //endregion

        DeleteRequest request = new DeleteRequest("test_index", "1");

        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

        System.out.println(response);
        client.close();
    }

    @Test
    public void multiGetById() throws IOException {
        //region Description
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")));
        //endregion

        //region Description
        //根据多个id查询
        MultiGetRequest request = new MultiGetRequest();
        //endregion

        //region Description
        request.add("test_index", "6");
        //两种写法
        request.add(new MultiGetRequest.Item(
                "test_index",
                "7"));
        //endregion

        //region Description
        MultiGetResponse response = client.mget(request, RequestOptions.DEFAULT);
        //endregion
        for (MultiGetItemResponse itemResponse : response) {
            System.out.println(itemResponse.getResponse().getSourceAsString());
        }
        client.close();
    }

    @Test
    public void updateByQuery() throws IOException {

        //region 连接
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")
                )
        );
        //endregion

        //region 请求对象
        UpdateByQueryRequest request = new UpdateByQueryRequest("test_index");
        //endregion

        //region 组装数据
        //默认情况下,版本冲突会中止 UpdateByQueryRequest 进程,但是你可以用以下命令来代替
        //设置版本冲突继续
//        request.setConflicts("proceed");
        //设置更新条件
        request.setQuery(QueryBuilders.termQuery("name", "name2"));
//        //限制更新条数
//        request.setMaxDocs(10);
        request.setScript(
                new Script(ScriptType.INLINE, "painless", "ctx._source.desc+='#';", Collections.emptyMap()));
        //endregion

        BulkByScrollResponse response = client.updateByQuery(request, RequestOptions.DEFAULT);

        System.out.println(response);
        client.close();
    }

优缺点

优点

        安全:REST API使用单一的集群入口点,可以通过 HTTPS 保障数据安全性,传输层只用于内部节点到节点的通信。
        易用:客户端只通过 REST 层而不是通过传输层调用服务,可以大大简化代码编写

 缺点

        性能略逊于Java API,但是差距不大

 Low level Client

 优点:
        轻依赖:Apache HTTP 异步客户端及其传递依赖项(Apache HTTP 客户端、Apache HTTP Core、Apache HTTP Core NIO、Apache Commons Codec 和 Apache Commons Logging)
        兼容性强:兼容所有ES版本
  缺点:
        功能少:显而易见,轻量化带来的必然后果

High level Client

 优点:
        功能强大:支持所有ES的API调用。
        松耦合:客户端和ES核心服务完全独立,无共同依赖。
         接口稳定:REST API 比与 Elasticsearch 版本完全匹配的`Transport Client`接口稳定得多。
缺点:
        兼容性中等:基于Low Level Client,只向后兼容ES的大版本,比如6.0的客户端兼容6.x(即6.0之后的版本),但是6.1的客户端未必支持所有6.0ES的API,但是这并不是什么大问题,咱们使用相同版本的客户端和服务端即可,而且不会带来其他问题。

Java Transport Client

使用的客户端名称叫TransportClient

从7.0.0开始,官方已经不建议使用TransportClient作为ES的Java客户端了,并且从8.0会被彻底删除

TransportClient 使用transport模块(9300端口)远程连接到 Elasticsearch 集群,客户端并不加入集群,而是通过获取单个或者多个transport地址来以轮询的方式与他们通信。


TransportClient使用transport协议与Elasticsearch节点通信,如果客户端的版本和与其通信的ES实例的版本不同,就会出现兼容性问题。而low-level REST使用的是HTTP协议,可以与任意版本ES集群通信。high-level REST是基于low-level REST的。

es整合java时,es的版本和java中的版本要保证大版本一致,比如,7.x

es的版本和springboot版本兼容性关系

Elasticsearch--客户端,elasticsearch

依赖

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

连接

// 创建客户端连接
TransportClient client = new PreBuiltTransportClient(Settings.EMPTY)
        .addTransportAddress(new TransportAddress(InetAddress.getByName("host1"), 9300))
        .addTransportAddress(new TransportAddress(InetAddress.getByName("host2"), 9300));

// 关闭客户端
client.close();

简单使用

    @SneakyThrows
    private void create(TransportClient client) {
        List<Product> list = service.list();
        for (Product item : list) {
            System.out.println(item.getDate().toLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            IndexResponse response = client.prepareIndex("product", "_doc", item.getId().toString())
                    .setSource(XContentFactory.jsonBuilder()
                            .startObject()
                            .field("name", item.getName())
                            .field("desc", item.getDesc())
                            .field("price", item.getPrice())
                            .field("date", item.getDate().toLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")))
                            .field("tags", item.getTags().replace("\"", "").split(","))
                            .endObject())
                    .get();
            System.out.println(response.getResult());
        }
    }

    @SneakyThrows
    private void get(TransportClient client) {
        GetResponse response = client.prepareGet("product", "_doc", "1").get();
        String index = response.getIndex();//获取索引名称
        String type = response.getType();//获取索引类型
        String id = response.getId();//获取索引id
        System.out.println("index:" + index);
        System.out.println("type:" + type);
        System.out.println("id:" + id);
        System.out.println(response.getSourceAsString());
    }

    private void getAll(TransportClient client) {
        SearchResponse response = client.prepareSearch("product")
                .get();
        SearchHits searchHits = response.getHits();
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String res = hit.getSourceAsString();
            System.out.println("res" + res);
        }
    }

    @SneakyThrows
    private void update(TransportClient client) {
        UpdateResponse response = client.prepareUpdate("product", "_doc", "2")
                .setDoc(XContentFactory.jsonBuilder()
                        .startObject()
                        .field("name", "update name")
                        .endObject())
                .get();
        System.out.println(response.getResult());
    }

    @SneakyThrows
    private void delete(TransportClient client) {
        DeleteResponse response = client.prepareDelete("product", "_doc", "2").get();
        System.out.println(response.getResult());
    }

kibana中操作的是Rest api

dsl转成代码

Elasticsearch--客户端,elasticsearch

  void aggSearch() {
        //region 1->创建客户端连接
        TransportClient client = new PreBuiltTransportClient(Settings.EMPTY)
                .addTransportAddress(new TransportAddress(InetAddress.getByName("localhost"), 9300));
        //endregion

        //region 2->计算并返回聚合分析response对象
        SearchResponse response = client.prepareSearch("product")
                .setSize(0)
                .setQuery(QueryBuilders.matchAllQuery())
                .addAggregation(AggregationBuilders.dateHistogram("group_by_month")
                        .field("date")
                        .calendarInterval(DateHistogramInterval.MONTH)
                        .minDocCount(1)
                        .subAggregation(AggregationBuilders.terms("by_tag")
                                .field("tags.keyword")
                                .subAggregation(AggregationBuilders.avg("avg_price")
                                        .field("price"))
                        )
                ).execute().actionGet();

        //endregion

        //region 3->输出结果信息
        SearchHit[] hits = response.getHits().getHits();
        Map<String, Aggregation> map = response.getAggregations().asMap();
        Aggregation group_by_month = map.get("group_by_month");
        Histogram dates = (Histogram) group_by_month;
        Iterator<Histogram.Bucket> buckets = (Iterator<Histogram.Bucket>) dates.getBuckets().iterator();
        while (buckets.hasNext()) {
            Histogram.Bucket dateBucket = buckets.next();
            System.out.println("\n月份:" + dateBucket.getKeyAsString() + "\n计数:" + dateBucket.getDocCount());
            Aggregation by_tag = dateBucket.getAggregations().asMap().get("by_tag");
            StringTerms terms = (StringTerms) by_tag;
            Iterator<StringTerms.Bucket> tags = terms.getBuckets().iterator();
            while (tags.hasNext()) {
                StringTerms.Bucket tag = tags.next();
                System.out.println("\t标签名称:" + tag.getKey() + "\n\t数量:" + tag.getDocCount());
                Aggregation avg_price = tag.getAggregations().get("avg_price");
                Avg avg = (Avg) avg_price;
                System.out.println("\t平均价格:" + avg.getValue());
            }
        }
        //endregion

        client.close();


    }


 

嗅探器sniffer

允许从正在运行的 Elasticsearch 集群中自动发现节点并将它们设置为现有 RestClient 实例的最小库(在集群中,根据一个节点找到其他节点)

依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client-sniffer</artifactId>
    <version>7.12.1</version>
</dependency>
// 默认每五分钟发现一次
RestClient restClient = RestClient.builder(
    new HttpHost("localhost", 9200, "http"))
    .build();
Sniffer sniffer = Sniffer.builder(restClient).build();



// 设置嗅探间隔
RestClient restClient = RestClient.builder(
    new HttpHost("localhost", 9200, "http"))
    .build();
// 设置嗅探间隔为60000毫秒
Sniffer sniffer = Sniffer.builder(restClient)
    .setSniffIntervalMillis(60000).build();



// 失败时重启嗅探
SniffOnFailureListener sniffOnFailureListener =
    new SniffOnFailureListener();
RestClient restClient = RestClient.builder(
    new HttpHost("localhost", 9200))
    .setFailureListener(sniffOnFailureListener) //将失败侦听器设置为 RestClient 实例 
    .build();
Sniffer sniffer = Sniffer.builder(restClient)
    .setSniffAfterFailureDelayMillis(30000) //在嗅探失败时,不仅节点在每次失败后都会更新,而且还会比平常更早安排额外的嗅探轮次,默认情况下是在失败后一分钟,假设事情会恢复正常并且我们想要检测尽快地。可以在 Sniffer 创建时通过 setSniffAfterFailureDelayMillis 方法自定义所述间隔。请注意,如果如上所述未启用故障嗅探,则最后一个配置参数无效。
    .build();
sniffOnFailureListener.setSniffer(sniffer); //将 Sniffer 实例设置为失败侦听器




// 资源释放  
// Sniffer 对象应该与RestClient 具有相同的生命周期,并在客户端之前关闭。
sniffer.close();
restClient.close();

Spring Data Elasticsearch

Spring Data 的目的是用统一的接口,适配所有不同的存储类型。

Spring Data Elasticsearch是Spring Data的一个子项目,该项目旨在为新数据存储提供熟悉且一致的基于 Spring 的编程模型,同时保留特定于存储的功能和功能。Spring Data Elasticsearch是一个以 POJO 为中心的模型,用于与 Elastichsearch 文档交互并轻松编写 Repository 风格的数据访问层

特点
  • Spring 配置支持使用基于 Java 的@Configuration类或用于 ES 客户端实例的 XML 命名空间。

  • ElasticsearchTemplate提高执行常见 ES 操作的生产力的助手类。包括文档和 POJO 之间的集成对象映射。

  • 功能丰富的对象映射与 Spring 的转换服务集成

  • 基于注释的映射元数据但可扩展以支持其他元数据格式

  • Repository接口的自动实现,包括对自定义查找器方法的支持。

  • 对存储库的 CDI 支持

 依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

注解

@Document:在类级别应用,以指示该类是映射到数据库的候选类。最重要的属性包括:

indexName:用于存储此实体的索引的名称。它可以包含类似于“日志-#{T(java.time.LocalDate).now().toString()}”

type :映射类型。如果未设置,则使用该类的小写简单名称。(自4.0版起已弃用)

createIndex:标记是否在存储库引导时创建索引。默认值为true。请参阅自动创建带有相应映射的索引

versionType:版本管理的配置。默认值为外部 .

@Id:在字段级别应用,以标记用于标识的字段。

@Transient:默认情况下,存储或检索文档时,所有字段都映射到文档,此批注不包括该字段。

@PersistenceConstructor:标记在从数据库实例化对象时要使用的给定构造函数(甚至是包受保护的构造函数)。构造函数参数按名称映射到检索文档中的键值。

@Field:应用于字段级别并定义字段的属性,大多数属性映射到相应的Elasticsearch映射定义(以下列表不完整,请查看注释Javadoc以获取完整的参考):

name:将在Elasticsearch文档中表示的字段的名称,如果未设置,则使用Java字段名称。

type:字段类型,可以是Text,关键字,Long,Integer,Short,Byte,Double,Float,Half_Float,Scaled_Float,日期,日期Nanos,Boolean,Binary,Integer_Range,Float_Range,Long_Range,DoubleˉRange,DateˉRange,Object,Nested,Ip,TokenCount,percollator,flatten,搜索。请参阅Elasticsearch映射类型

format:一个或多个内置日期格式,请参阅下一节格式数据映射 .

pattern:一个或多个自定义日期格式,请参阅下一节格式数据映射 .

store:标志是否应将原始字段值存储在Elasticsearch中,默认值为假 .

analyzer ,搜索分析器 ,normalizer用于指定自定义分析器和规格化器。

@GeoPoint:将字段标记为地理点如果字段是GeoPoint班级

 简单使用文章来源地址https://www.toymoban.com/news/detail-566523.html

public class EsUtil {
    // 生成批量处理对象
    private static BulkRequest bulkRequest = new BulkRequest();

    /**
     * 添加数据到es
     * @param indexName
     * @param typeName
     * @param indexId
     * @param json
     */

    public static void add(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId, Map<String, Object> json) throws IOException {
        IndexRequest indexRequest = new IndexRequest(indexName, typeName,indexId);
//        Gson gson = new Gson();
        indexRequest.source(new JSONObject(json).toString(), XContentType.JSON);
        try {
            restHighLevelClient.index(indexRequest,RequestOptions.DEFAULT);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 判断索引名是否存在
     * @param indexName
     * @return
     */
    public static boolean existsIndex(RestHighLevelClient restHighLevelClient,String indexName) {
        try{
            GetIndexRequest request = new GetIndexRequest(indexName);
            boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
            return exists;
        }catch (Exception e){
            System.out.println("Exception");
        }
        return false;
    }
    /**
     * @param : client
     * @description : 判断文档是否存在
     */
    public static boolean isExist(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId) throws IOException{

        GetRequest request = new GetRequest(indexName, typeName, indexId);
        //1.同步判断
        boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);

        //2.异步判断
        ActionListener<Boolean> listener = new ActionListener<Boolean>() {
            @Override
            public void onResponse(Boolean exists) {
                if (exists){
                    System.out.println("文档存在");
                }else {
                    System.out.println("文档不存在");
                }
            }

            @Override
            public void onFailure(Exception e) {

            }
        };
        //client.existsAsync(request, RequestOptions.DEFAULT, listener);

        return exists;
    }

    /**
     * @param : client
     * @description : 删除文档
     */
    public static void deleteDocument(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId) throws IOException{

        DeleteRequest request = new DeleteRequest(indexName,typeName,indexId);

        //设置请求超时时间:2分钟
        request.timeout(TimeValue.timeValueMinutes(2));
        //request.timeout("2m");

        //同步删除
        DeleteResponse deleteResponse = restHighLevelClient.delete(request, RequestOptions.DEFAULT);

        //异步删除
        ActionListener<DeleteResponse> listener = new ActionListener<DeleteResponse>() {
            @Override
            public void onResponse(DeleteResponse deleteResponse) {
                System.out.println("删除后操作");
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("删除失败");
            }
        };

    }

    /**
     * 批量增加数据的方法
     * @param restHighLevelClient
     * @param indexname
     * @param typename
     * @param row_key
     * @param map
     * @throws Exception
     */
    public void bulkadd(RestHighLevelClient restHighLevelClient, String indexname, String typename, String row_key, Map<String,Object> map) throws Exception {

        try {
            // 生成批量处理对象
            //BulkRequest bulkRequest = new BulkRequest();

            // 得到某一行的数据,并封装成索引对象
            IndexRequest indexRequest = new IndexRequest(indexname, typename,row_key);
            indexRequest.source(new JSONObject(map).toString(), XContentType.JSON);


            //判断是否执行加载
            if (bulkRequest.numberOfActions() != 0 && (bulkRequest.numberOfActions() > 100)) {
                try {
                    bulkRequest(restHighLevelClient);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 装填数据
            bulkRequest.add(indexRequest);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            bulkRequest(restHighLevelClient);
        }
    }

    /**
     * 批量具体执行方法
     * execute bulk process
     * @throws Exception
     */
    private void bulkRequest(RestHighLevelClient restHighLevelClient) throws Exception {
        // 加载数据
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        // 判断加载情况
        if(bulkResponse.hasFailures()){
            System.out.println("失败");
        }else{
            System.out.println("成功");
            // 重新定义
            bulkRequest = new BulkRequest();

        }
    }

}

到了这里,关于Elasticsearch--客户端的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Elasticsearch Java客户端和Spring data elasticsearch-Elasticsearch文章三

    https://www.elastic.co/cn/ 整合springboot看上一篇文章 一定要对应好版本,Elasticsearch 的不同版本变化是真大, https://docs.spring.io/spring-data/elasticsearch/docs/4.4.10/reference/html/ Springboot: 2.7.10 spring-data-elasticsearch: 4.4.10 spring-boot-starter-data-elasticsearch: 2.7.10 elasticsearch-java: 7.17.9 https://github.com/

    2024年02月14日
    浏览(43)
  • ElasticSearch-学习笔记04【Java客户端操作索引库】

    Java后端-学习路线-笔记汇总表【黑马程序员】 ElasticSearch-学习笔记01【ElasticSearch基本介绍】 【day01】 ElasticSearch-学习笔记02【ElasticSearch索引库维护】 ElasticSearch-学习笔记03【ElasticSearch集群】 ElasticSearch-学习笔记04【Java客户端操作索引库】 【day02】 ElasticSearch-学习笔记05【Spri

    2023年04月09日
    浏览(49)
  • SpringBoot集成Elasticsearch客户端(新旧版本)(2023-01-28)

    第一章 SpringBoot集成ElasticSearch(2023-01-28) 例如:业务中需要使用es,所以做一些客户端选型,熟悉一下基本的操作,所以记录这篇博客,有关概念理论性的文章还在整理过程中,后续会整理个系列 Spring认证中国教育管理中心-Spring Data Elasticsearch教程一 SpringData集成Elasticsearch Sp

    2024年02月07日
    浏览(74)
  • 干货 | Elasticsearch Java 客户端演进历史和选型指南

    Elasticsearch 官方提供了很多版本的 Java 客户端,包含但不限于: Transport 客户端 Java REST 客户端 Low Level REST 客户端 High Level REST 客户端 Java API 客户端 非官方的 Java 客户端,包含但不限于: Jest 客户端 BBoss 客户端 Spring Data Elasticsearch 客户端 ...... 写出来的就接近十款客户端! El

    2023年04月11日
    浏览(51)
  • es(Elasticsearch)客户端Elasticsearch-head安装使用(04Elasticsearch-head安装篇)

    elasticsearch-head是一款专门针对于elasticsearch的客户端工具,用来展示数据。elasticsearch-head是基于JavaScript语言编写的,可以使用npm部署,npm是Nodejs下的包管理器 安裝方式利用npm和nodejs进行安装启动,github中给出的安装方法也是这种,本文就是以这种方式进行解说 es(Elasticsearc

    2024年01月17日
    浏览(53)
  • 可选择的Elasticsearch好用的可视化客户端工具

    常言道:工欲善其事,必先利其器。对于我们开发和测试同学来说,在日常的工作中有一款趁手的工具那真实如虎添翼啊,工作效率可是蹭蹭蹭的往上长,节省下来的时间摸摸鱼该有多好啊。最近我们系统开始使用elasticsearch来支持搜索,于是就想在网上找一款类似于Navicat之

    2024年02月02日
    浏览(185)
  • 袁庭新ES系列15节|Elasticsearch客户端基础操作

    上一章节我们介绍了搭建Elasticsearch集群相关的知识。那么又该如何来操作Elasticsearch集群呢?在ES官网中提供了各种语言的客户端,我们在项目开发过程中有多种Elasticsearch版本和连接客户端可以选择,那么他们有什么区别?这一章节袁老师带领大家来学习Elasticsearch客户端相关

    2024年04月25日
    浏览(51)
  • windows环境安装elasticsearch+kibana并完成JAVA客户端查询

    elasticsearch 官网下载比较慢,有时还打不开,可以通过https://elasticsearch.cn/download/下载,先找到对应的版本,最好使用迅雷下载,秒下的,我的下载速度可以达到40M/S 解压后点击 elasticsearch-7.10.0binelasticsearch.bat 运行成功后,输入http://120.0.0.1:9200,可以访问说明ES启动成功 点击

    2024年02月14日
    浏览(52)
  • Elasticsearch8.x版本Java客户端Elasticsearch Java API Client中常用API练习

    在Es7.15版本之后,es官方将它的高级客户端RestHighLevelClient标记为弃用状态。同时推出了全新的java API客户端Elasticsearch Java API Client,该客户端也将在Elasticsearch8.0及以后版本中成为官方推荐使用的客户端。 Elasticsearch Java API Client支持除Vector title search API和Find structure API之外的所有

    2024年04月11日
    浏览(49)
  • [elastic 8.x]java客户端连接elasticsearch与操作索引与文档

    为了方便演示,我关闭了elasticsearch的安全验证,带安全验证的初始化方式将在最后专门介绍 其中,HotelDoc是一个实体类 带安全验证的连接有点复杂,将下列代码中CA证书的位置改为实际所在的位置就行了。 password为elastic的密码,可以在我的另一篇文章中查看密码的重置方式

    2024年04月11日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包