ElasticSearch之JAVA的API接口简单应用

最新推荐文章于 2024-07-29 10:48:46 发布
最新推荐文章于 2024-07-29 10:48:46 发布
阅读量235 收藏 1
点赞数 1
分类专栏： ElasticSearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p_ning/article/details/118659008
版权

API接口简单应用

索引

package com.api.simply;

import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.junit.Test;
import sun.rmi.runtime.Log;

import java.io.IOException;

/**
 * @Author Pning
 * @Date 2021/7/6 10:10
 **/

//索引的创建、查询和刪除
public class IndexDemo {

    /**
     * 连接ES
     * @throws IOException
     */
    @Test
    public void ESConnect() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 关闭客户端连接
        client.close();
    }


    /**
     * 创建索引
     * @throws IOException
     */
    @Test
    public void creatIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建索引 - 请求对象
        CreateIndexRequest request = new CreateIndexRequest("user");//必须小写
        // 发送请求，获取响应
        CreateIndexResponse response = client.indices().create(request,
                RequestOptions.DEFAULT);
        boolean acknowledged = response.isAcknowledged();
        // 响应状态
        System.out.println("操作状态 = " + acknowledged);
        client.close();
    }
    /**
     * 查看索引
     * @throws IOException
     */
    @Test
    public void getIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 查询索引 - 请求对象
        GetIndexRequest request = new GetIndexRequest("user");
        // 发送请求，获取响应
        GetIndexResponse response = client.indices().get(request,
                RequestOptions.DEFAULT);
        System.out.println("aliases:"+response.getAliases());
        System.out.println("mappings:"+response.getMappings());
        System.out.println("settings:"+response.getSettings());
        client.close();
    }

    /**
     * 删除索引
     * @throws IOException
     */
    @Test
    public void deleteIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 删除索引 - 请求对象
        DeleteIndexRequest request = new DeleteIndexRequest("user");
        // 发送请求，获取响应
        AcknowledgedResponse response = client.indices().delete(request,
                RequestOptions.DEFAULT);
        // 操作结果
        System.out.println("操作结果 ： " + response.isAcknowledged());
    }
}

文档

添加插入

package com.api.simply;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.pojo.User;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;

import java.io.IOException;

/**
 * @Author Pning
 * @Date 2021/7/6 11:14
 **/
public class DocumentInsertDemo {

    /**
     * 插入单条文档数据
     * @throws IOException
     */
    @Test
    public void insertDocumentOne() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 新增文档 - 请求对象
        IndexRequest request = new IndexRequest();
        // 设置索引及唯一性标识
        request.index("user").id("1001");
        // 创建数据对象
        User user = new User();
        user.setName("pning");
        user.setAge(20);
        user.setSex("男");
        ObjectMapper objectMapper = new ObjectMapper();
        String productJson = objectMapper.writeValueAsString(user);
        // 添加文档数据，数据格式为 JSON 格式
        request.source(productJson, XContentType.JSON);
        // 客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        System.out.println("_index:" + response.getIndex());
        System.out.println("_id:" + response.getId());
        System.out.println("_result:" + response.getResult());
        // 关闭客户端连接
        client.close();
    }

    /**
     * 批量插入文档数据
     * @throws IOException
     */
    @Test
    public void insertDocumentList() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 批量插入数据
        BulkRequest request = new BulkRequest();
        //如果重复插入同一个id会覆盖原本的数据
        for(int i=0;i<10;i++){
            request.add(new IndexRequest().index("user").id("100"+i).source(XContentType.JSON, "name", "pning_"+i, "age",20+i,"sex","男"));
        }
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println("耗时:"+response.getTook());
        System.out.println("是否报错:" + response.hasFailures());
        System.out.println("返回对象" + response.getItems());
        // 关闭客户端连接
        client.close();
    }
}

查询

package com.api.simply;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.pojo.User;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.index.query.TermsQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

/**
 * @Author Pning
 * @Date 2021/7/6 11:14
 **/
public class DocumentQueryDemo {

    /**
     * 查询文档数据
     * @throws IOException
     */
    @Test
    public void queryDocumentOne() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        //1.创建请求对象
        GetRequest request = new GetRequest().index("user").id("1000");
        //2.客户端发送请求，获取响应对象
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        System.out.println("_index:" + response.getIndex());
        System.out.println("_type:" + response.getType());
        System.out.println("_id:" + response.getId());
        System.out.println("source:" + response.getSourceAsString());
        // 关闭客户端连接
        client.close();
    }

    /**
     * 请求体查询所有
     * @throws IOException
     */
    @Test
    public void queryDocumentAll() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 查询所有数据
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        sourceBuilder.size(50);//查询数量
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        client.close();
    }

    /**
     * term 查询，查询条件为关键字
     */
    @Test
    public void query() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.termQuery("age", "30"));
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
    }

    /**
     * 分页查询
     * @throws IOException
     */
    @Test
    public void DocumentByPage() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        // 分页查询
        // 当前页其实索引(第一条数据的顺序号)，from
        sourceBuilder.from(0);
        // 每页显示多少条 size
        sourceBuilder.size(5);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
            //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        // 关闭客户端连接
        client.close();
    }

    /**
     * 排序查询
     * @throws IOException
     */
    @Test
    public void DocumentOrder() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        // 排序
        sourceBuilder.sort("age", SortOrder.ASC);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
            //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        // 关闭客户端连接
        client.close();
    }


    /**
     * 返回信息过滤查询
     * @throws IOException
     */
    @Test
    public void DocumentFilter() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //查询返回字段过滤
        String[] excludes = {};
        String[] includes = {"name", "age"};
        sourceBuilder.fetchSource(includes, excludes);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        // 关闭客户端连接
        client.close();
    }

    /**
     *  Bool多条件且或查询
     * @throws IOException
     */
    @Test
    public void DocumentBool() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 必须包含
        boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
        // 一定不含
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhangsan"));
        // 可能包含
        boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));
        sourceBuilder.query(boolQueryBuilder);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        // 关闭客户端连接
        client.close();
    }

    /**
     * 范围查询
     * @throws IOException
     */
    @Test
    public void DocumentRange() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
        // 大于等于
        rangeQuery.gte("30");
        // 小于等于
        rangeQuery.lte("40");
        sourceBuilder.query(rangeQuery);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");

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

    /**
     * 模糊查询(可以设置几个字符不一样也能被查询)
     * @throws IOException
     */
    @Test
    public void DocumentFuzzyQuery() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置模糊查询条件和设置几个字符不一样也能被查询
        sourceBuilder.query(QueryBuilders.fuzzyQuery("name","pning_1").fuzziness(Fuzziness.ONE));
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
        //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
        // 关闭客户端连接
        client.close();
    }


    /**
     * 高亮查询
     * @throws IOException
     */
    @Test
    public void DocumentHighLightQuery() throws IOException {
        // 1.创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        SearchRequest request = new SearchRequest().indices("user");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：高亮查询
        TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("name","pning_16");
        //设置查询方式
        sourceBuilder.query(termsQueryBuilder);
        //构建高亮字段
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<font color='red'>");//设置标签前缀
        highlightBuilder.postTags("</font>");//设置标签后缀
        highlightBuilder.field("name");//设置高亮字段
        //设置高亮构建对象
        sourceBuilder.highlighter(highlightBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took:"+response.getTook());
        System.out.println("time_out:"+response.isTimedOut());
        System.out.println("total:"+hits.getTotalHits());
        System.out.println("max_score:"+hits.getMaxScore());
        System.out.println("hits===>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        //打印高亮结果
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields);
        }
        System.out.println("<<===");
        // 关闭客户端连接
        client.close();
    }


    /**
     * 集合查询:最大年龄
     * @throws IOException
     */
    @Test
    public void DocumentGatherQuery() throws IOException {
        // 1.创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        SearchRequest request = new SearchRequest().indices("user");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //maxAge只是随便取得一个名字,作用是方便前端取值
        sourceBuilder.aggregation(AggregationBuilders.max("maxAge").field("age"));
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println(response);
        // 关闭客户端连接
        client.close();
    }

    /**
     * 分组统计
     * @throws IOException
     */
    @Test
    public void DocumentGroupingQuery() throws IOException {
        // 1.创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        SearchRequest request = new SearchRequest().indices("user");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //age_groupby只是随便取得一个名字,作用是方便前端取值
        sourceBuilder.aggregation(AggregationBuilders.terms("age_groupby").field("age"));
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println(response);
        // 关闭客户端连接
        client.close();
    }
}

更新

package com.api.simply;

import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.Test;

import java.io.IOException;

/**
 * @Author Pning
 * @Date 2021/7/6 11:14
 **/
public class DocumentUpdateDemo {

    /**
     * 修改单条文档数据
     * @throws IOException
     */
    @Test
    public void UpdateDocumentOne() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        // 修改文档 - 请求对象
        UpdateRequest request = new UpdateRequest();
        // 配置修改参数
        request.index("user").id("1000");
        // 设置请求体，对数据进行修改
        request.doc(XContentType.JSON, "sex", "男的");
        // 客户端发送请求，获取响应对象
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println("_index:" + response.getIndex());
        System.out.println("_id:" + response.getId());
        System.out.println("_result:" + response.getResult());
        // 关闭客户端连接
        client.close();
    }
    /**
     * 批量修改文档数据
     * @throws IOException
     */
    @Test
    public void UpdateDocumentList() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        //创建批量修改文档 - 请求对象
        BulkRequest request = new BulkRequest();
        request.add(new UpdateRequest().index("user").id("1000").doc(XContentType.JSON, "sex", "男的"));
        request.add(new UpdateRequest().index("user").id("1001").doc(XContentType.JSON, "sex", "男的"));
        request.add(new UpdateRequest().index("user").id("1002").doc(XContentType.JSON, "sex", "男的"));
        request.add(new UpdateRequest().index("user").id("1003").doc(XContentType.JSON, "sex", "男的"));
        //客户端发送请求，获取响应对象
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        //打印结果信息
        System.out.println("耗时:"+response.getTook());
        System.out.println("是否报错:" + response.hasFailures());
        System.out.println("返回对象" + response.getItems());
        // 关闭客户端连接
        client.close();
    }

}

删除

package com.api.simply;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.pojo.User;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;

import java.io.IOException;

/**
 * @Author Pning
 * @Date 2021/7/6 11:14
 **/
public class DocumentDeleteDemo {

    /**
     * 删除单条文档数据
     * @throws IOException
     */
    @Test
    public void DeleteDocumentOne() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        //创建请求对象
        DeleteRequest request = new DeleteRequest().index("user").id("1000");
        //客户端发送请求，获取响应对象
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        //打印信息
        System.out.println("返回对象信息"+response.toString());
        // 关闭客户端连接
        client.close();
    }

    /**
     * 批量删除文档数据
     * @throws IOException
     */
    @Test
    public void DeleteDocumentList() throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        //创建批量删除请求对象
        BulkRequest request = new BulkRequest();
        request.add(new DeleteRequest().index("user").id("1002"));
        request.add(new DeleteRequest().index("user").id("1003"));
        request.add(new DeleteRequest().index("user").id("1004"));
        //客户端发送请求，获取响应对象
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
         //打印结果信息
        System.out.println("耗时:"+response.getTook());
        System.out.println("是否报错:" + response.hasFailures());
        System.out.println("返回对象" + response.getItems());
        // 关闭客户端连接
        client.close();
    }


}
P_ning
关注
专栏目录
ElasticSearch Java API 中文文档
01-04
ElasticSearch Java API 中文文档 ElasticSearch Java API 中文文档
elasticSearch java api接口
weixin_45568648的博客
05-28 725
引入pom依赖 这个是包装了方法的es客户端 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.7.0</version> </dependency> 我们也可以用spr
Elasticsearch——搜索API详解
最新发布
smart_an的专栏
07-29 1088
场景：例如想要搜索博客信息，搜索的关键字是java，但是我们希望能够将评分较高的博客优先展示出来。但是默认的评分策略是没有办法考虑到评分的，他只是考虑相关性，这个时候可以通过 function_score query 来实现。PUT /blog"title": {},"votes": {"title": "Java集合详解","title": "Java多线程详解，Java锁详解","query": {"match": {默认情况，votes为10的评分更高。
elasticsearch Java接口汇总
hebeind100的博客
09-23 258
服务器端和客户端的elasticsearch版本号须一致   setExplain(true)设置是否按查询匹配度排序   import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry;  ...
ElasticSearch 入门（五）Rest风格说明
名字好难想
03-13 389
基本Rest命令说明： 测试 1、创建一个索引，添加 PUT /test1/type1/1 { "name" : "流柚", "age" : 18 } 2、字段数据类型 字符串类型 text、keyword text：支持分词，全文检索,支持模糊、精确查询,不支持聚合,排序操作;text类型的最大支持的字符长度无限制,适合大字段存储； keyword：不进行分词，直接索引、支持模糊、支持精确匹配，支持聚合、排序操作。keyword类型的最大支持的长度为——32766个UTF-8类型的字符,可
ElasticSearch java API
03-27
ElasticSearch 官方 java API
基于Elasticsearch Java API的参考手册
04-29
**Elasticsearch Java API详解** Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，广泛应用于大数据领域的实时分析和信息检索。Java API是Elasticsearch官方提供的与Elasticsearch服务器进行交互的...
elasticsearch java api 离线文档
01-11
Java API 是 Elasticsearch 提供的用于与集群交互的主要接口，允许开发者在 Java 应用程序中方便地集成 Elasticsearch 功能。 在 Java 应用程序中使用 Elasticsearch，开发者可以利用 Java API 来执行索引、搜索、...
elasticsearch java api
12-25
总的来说，Elasticsearch 2.3的Java API提供了一个强大且灵活的工具集，使得在Java环境中与Elasticsearch的交互变得简单而高效。无论是在开发搜索引擎、日志分析系统还是其他需要大数据处理的项目中，它都是一个不可...
Java ElasticSearch接口 一键粘贴即用
Richrichrichrich的博客
12-20 129
Java ElasticSearch接口 一键粘贴即用
elasticsearch相关java API（详细版）
weixin_40496191的博客
03-17 1184
elasticsearch查询数据的操作基本上都差不多，主要不同的是查询条件的组合。
ElasticSearch接口
09-16
搜索索引技术Java接口，与solr类似。值得学习
elasticsearch java操作的api实例
04-20
包含所因的索引建立、删除、查看，批量创建索引；搜索Query、过滤器 、分组高亮显示；以及创建Mapping
Elasticsearch Java API基础
weixin_53860667的博客
04-09 151
记录Elasticsearch Java API基础语法
Elasticsearch API接口介绍
morris
12-04 2832
容量控制 _split接口 _split接口可以在新索引中将每个主分片分裂为两个或更多分片，所以使用split扩容时分片总量都是成倍增加而不能逐个增加。使用split接口分裂分片虽然会创建新的索引，但新索引中的数据只是通过文件系统硬连接到新索引中，所以并不存在数据复制过程。而扩容的分片又是在本地分裂，所以不存在不同节点间网络传输数据的开销，所以split扩容效率相对其他方案来说还是比较高的。 _split接口做动态扩容需要预先设置索引的number_of_routing_shards参数，Elasticse
ElasticSearch Java Api
Jornici的博客
04-09 252
//2.添加配置 @Configuration //xml public class ElasticSearchClientConfig { @Bean //bean Class //bean id public RestHighLevelClient restHighLevelClient() { RestHighLevelClient client = new RestHighLevelClient( Rest.
elasticsearch基本接口使用
weixin_30950237的博客
10-23 227
一、查看当前es上的所有索引 curl -XGET "http://127.0.0.1:9200/_cat/indices" 　　 # 查看索引缩略信息 curl -XGET "http://127.0.0.1:9200/_cat/indices?v" 　　# 查看索引详细信息 二、查看elasticsearch集群状态 curl -sXGET "http://127....
Elasticsearch-javaAPI
qq_30657195的博客
06-24 423
1.创建maven项目 编辑器：IDEA 创建项目完成后，将maven配置到自己安装的位置，并将setting文件和repository配置好。 2.pom文件依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</ve
ElasticSearch的Java API
weixin_43303455的博客
10-27 1787
@TOC Java客户端 在Elasticsearch中，为java提供了2种客户端，一种是REST风格的客户端，另一种是Java API的客户端。 官网： https://www.elastic.co/guide/en/elasticsearch/client/index.html REST客户端 Elasticsearch提供了2种REST客户端，一种是低级客户端，一种是高级客户端。 Java Low Level REST Client: 官方提供的低级客户端。该客户端通过http来连接Elasti
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值