java操作 elasticsearch8.0 doc文档＜二＞

已于 2022-02-27 23:26:34 修改
阅读量6k 收藏 35
点赞数 11
分类专栏： elasticsearch8 文章标签： java 开发语言 后端 elasticsearch
于 2022-02-27 23:19:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013979493/article/details/123172320
版权

java操作 elasticsearch8.0 doc文档＜二＞

本文所有代码在文章最后

本文所有代码在文章最后

创建doc文档

如何连接请看上一篇文章

https://blog.csdn.net/u013979493/article/details/123122242?spm=1001.2014.3001.5502

User user = new User("10002", "lisi", 20, "男");
IndexResponse indexResponse = client.index(
              x -> x.index("user").id(user.getId()).document(user));

修改doc自定义属性

User user = new User();
//修改什么属性就set什么值
user.setAge(101);
UpdateResponse<User> userUpdateResponse = client.update(
                     x -> x.index("user").id("10002").doc(user), User.class);

获取doc信息

GetResponse<User> getResponse = client.get(x -> x
	.index("user")
	.id("10002")
, User.class);

删除doc

client.delete(x -> x.index("user").id("10002"));

批量添加doc

//创建user列表
List<User> users = new ArrayList<>();
users.add(new User("15", "张三", 10, "女"));
users.add(new User("16", "张四", 10, "女"));
users.add(new User("17", "张五六", 11, "女"));
users.add(new User("18", "张三四", 12, "女"));
users.add(new User("19", "张三五", 13, "女"));
users.add(new User("20", "张三六七", 14, "女"));
users.add(new User("21", "张三1", 15, "女"));
//创建BulkOperation列表准备批量插入doc
List<BulkOperation> bulkOperations = new ArrayList<>();
//将user中id作为es id，也可不指定id es会自动生成id
users.forEach(a -> bulkOperations.add(BulkOperation.of(b -> b.index(c -> c.id(a.getId()).document(a)))));
client.bulk(x ->x.index("user").operations(bulkOperations));

批量删除doc

List<String> strings = new ArrayList<>();
strings.add("1");
strings.add("2");
strings.add("3");
strings.add("4");
strings.add("5");
strings.add("6");
strings.add("7");
List<BulkOperation> bulkOperations = new ArrayList<>();
strings.forEach(a -> bulkOperations.add(BulkOperation.of(b -> b.delete(c -> c.id(a)))));
client.bulk(x ->x.index("user").operations(bulkOperations));

批量更新doc

与添加删除同理

查询user索引所有数据

SearchResponse<User> searchResponse = client.search(a -> a.index("user"), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

条件查询 查询age为15的数据

earchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .term(c -> c
                                            .field("age")
                                            .value(d -> d
                                                    .longValue(15)
                                            )
                                    )
                            ), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

分页查询 排序 过滤字段

SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            //从第0条到第4条
                            .from(0)
                            .size(5)
                            //按年龄降序排序
                            .sort(b -> b
                                    .field(c -> c
                                            .field("age")
                                            .order(SortOrder.Desc)
                                    )
                            )
                            .source(c -> c
                                    .filter(d -> d
                                            //不包含字段
                                            .excludes("id", "age")
                                            //包含字段
                                            .includes("name")
                                    )
                            ), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

组合查询

SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .bool(c -> c
                                    		//必须不满足某些条件
                                            .mustNot(d -> d.match(e -> e.field("sex").query(f -> f.stringValue("男"))))
                                            //可同时满足某些条件
                                            .should(d -> d.match(e -> e.field("age").query(f -> f.longValue(10))))
                                            .should(d -> d.match(e -> e.field("age").query(f -> f.longValue(12))))
                                    )
                            ), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

范围查询

from to查询

SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .range(c -> c.field("age").from("10").to("12"))
                            ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

大于小于查询

SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    //小于等于
//                                    .range(c -> c.field("age").lte(JsonData.of("13")))
                                    //小于
//                                    .range(c -> c.field("age").lt(JsonData.of("13")))
                                    //大于等于
//                                    .range(c -> c.field("age").gte(JsonData.of("13")))
                                    //大于
//                                    .range(c -> c.field("age").gt(JsonData.of("13")))
                                    //范围
                                    .range(c -> c.field("age").from("10").to("13"))

                            )
                            .sort(b -> b.field(c -> c.field("age").order(SortOrder.Asc)))
                            //经测试，若不指定size则只会返回前十条数据，此处这是size是想返回所有数据，如有更好的方法清指教
                            .size(1000), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

模糊查询 高亮显示

SearchResponse<User> searchResponse = client.search(_0 -> _0
                    .query(_1 -> _1
                            .fuzzy(_2 -> _2
                                    .field("name")
                                    //最大偏移量，意为最多有能有几个不符合的
                                    .fuzziness("1")
                                    //最大查询数量
//                                    .maxExpansions(5)
                                    .value(_3 -> _3
                                            .stringValue("张四")
                                    )
                            )
                    )
                    //高亮
                    .highlight(_4 -> _4
                            .fields("name", _5 -> _5
                                    .preTags("<font color='red'>")
                                    .postTags("</font>")
                            )
                    ), User.class);
searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));

聚合操作

SearchResponse<Map> search = client
                    .search(_0 -> _0
                    		//按年龄进行分组
                            .aggregations("ageGroup", _1 -> _1
                                    .terms(_2 -> _2
                                            .field("age")
                                    )
                            ), Map.class);
System.out.println(search);

本文所有方法本人以测试正常使用，如有错误请指正，一起讨论
以下为本文所有代码

User实体类

public class User {
    private String id;
    private String name;
    private int age;
    private String sex;

    public User() {
    }

    public User(String id, String name, int age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

es操作

public class ESClientDemo {

    private static final String clusterNodes = "127.0.0.1:9201";

    private static final String account = "elastic";

    private static final String passWord = "D4ibOD8mtcItd_p_FGUO";

    public static ElasticsearchClient client;

    public static RestClientBuilder builder;

    public static RestClient restClient;

    public static ElasticsearchTransport transport;

    //有密码登录
    public static void main(String[] args) {
        try {
            HttpHost[] httpHosts = Arrays.stream(clusterNodes.split(",")).map(x -> {
                String[] hostInfo = x.split(":");
                return new HttpHost(hostInfo[0], Integer.parseInt(hostInfo[1]));
            }).toArray(HttpHost[]::new);

            final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            //设置账号密码
            credentialsProvider.setCredentials(
                    AuthScope.ANY, new UsernamePasswordCredentials(account, passWord));

            builder = RestClient.builder(httpHosts)
                    .setHttpClientConfigCallback(httpClientBuilder ->
                            httpClientBuilder
                                    .setDefaultCredentialsProvider(credentialsProvider));

            // Create the low-level client
            restClient = builder.build();
            // Create the transport with a Jackson mapper
            transport = new RestClientTransport(
                    restClient, new JacksonJsonpMapper());
            // And create the API client
            client = new ElasticsearchClient(transport);

//            Boolean acknowledged = client.indices().create(c -> c.index("user")).acknowledged();
//            System.out.println("创建索引: " + (Boolean.TRUE.equals(acknowledged) ? "成功" : "失败"));
//            GetIndexResponse getIndexResponse = client.indices().get(c -> c.index("user"));
//            System.out.println("获取索引 user 响应: " + getIndexResponse);
//            DeleteIndexResponse deleteIndexResponse = client.indices().delete(c -> c.index("user"));
//            System.out.println("删除索引 user 响应: " + deleteIndexResponse);

            //创建doc
//            User user = new User("lisi", 20, "男");
//            IndexResponse indexResponse = client.index(
//                            x -> x.index("user").id("10002").document(user));
            //修改doc部分属性
//            User user = new User();
//            user.setAge(101);
//            UpdateResponse<User> userUpdateResponse = client.update(
//                            x -> x.index("user").id("10002").doc(user), User.class);
            //获取doc信息
//            GetResponse<User> getResponse = client.get(x -> x.index("user").id("10002"), User.class);
            //删除doc
//            client.delete(x -> x.index("user").id("10002"));

            //批量添加doc
            /*List<User> users = new ArrayList<>();
            users.add(new User("15", "张三", 10, "女"));
            users.add(new User("16", "张四", 10, "女"));
            users.add(new User("17", "张五六", 11, "女"));
            users.add(new User("18", "张三四", 12, "女"));
            users.add(new User("19", "张三五", 13, "女"));
            users.add(new User("20", "张三六七", 14, "女"));
            users.add(new User("21", "张三1", 15, "女"));
            List<BulkOperation> bulkOperations = new ArrayList<>();
            users.forEach(a -> bulkOperations.add(BulkOperation.of(b -> b.index(c -> c.id(a.getId()).document(a)))));
            client.bulk(x ->x.index("user").operations(bulkOperations));*/

            //批量删除doc
            /*List<String> strings = new ArrayList<>();
            strings.add("1");
            strings.add("2");
            strings.add("3");
            strings.add("4");
            strings.add("5");
            strings.add("6");
            strings.add("7");
            List<BulkOperation> bulkOperations = new ArrayList<>();
            strings.forEach(a -> bulkOperations.add(BulkOperation.of(b -> b.delete(c -> c.id(a)))));
            client.bulk(x ->x.index("user").operations(bulkOperations));*/

            //查询user索引所有数据
            /*SearchResponse<User> searchResponse = client.search(a -> a.index("user"), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //条件查询
            /*SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .term(c -> c
                                            .field("age")
                                            .value(d -> d
                                                    .longValue(15)
                                            )
                                    )
                            ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //分页查询 排序 过滤字段
            /*SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .from(0)
                            .size(5)
                            .sort(b -> b
                                    .field(c -> c
                                            .field("age")
                                            .order(SortOrder.Desc)
                                    )
                            )
                            .source(c -> c
                                    .filter(d -> d
                                            //不包含字段
                                            .excludes("id", "age")
                                            //包含字段
                                            .includes("name")
                                    )
                            ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //组合查询
            /*SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .bool(c -> c
                                            .mustNot(d -> d.match(e -> e.field("sex").query(f -> f.stringValue("男"))))
                                            .should(d -> d.match(e -> e.field("age").query(f -> f.longValue(10))))
                                            .should(d -> d.match(e -> e.field("age").query(f -> f.longValue(12))))
                                    )
                            ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //范围查询
            /*SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    .range(c -> c.field("age").from("10").to("12"))
                            ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/
            /*SearchResponse<User> searchResponse = client
                    .search(a -> a
                            .index("user")
                            .query(b -> b
                                    //小于等于
//                                    .range(c -> c.field("age").lte(JsonData.of("13")))
                                    //小于
//                                    .range(c -> c.field("age").lt(JsonData.of("13")))
                                    //大于等于
//                                    .range(c -> c.field("age").gte(JsonData.of("13")))
                                    //大于
//                                    .range(c -> c.field("age").gt(JsonData.of("13")))
                                    //范围
                                    .range(c -> c.field("age").from("10").to("13"))

                            )
                            .sort(b -> b.field(c -> c.field("age").order(SortOrder.Asc)))
                            .size(999999999), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //模糊查询 高亮显示
            /*SearchResponse<User> searchResponse = client.search(_0 -> _0
                    .query(_1 -> _1
                            .fuzzy(_2 -> _2
                                    .field("name")
                                    //最大偏移量
                                    .fuzziness("1")
                                    //最大查询数量
//                                    .maxExpansions(5)
                                    .value(_3 -> _3
                                            .stringValue("张四")
                                    )
                            )
                    )
                    .highlight(_4 -> _4
                            .fields("name", _5 -> _5
                                    .preTags("<font color='red'>")
                                    .postTags("</font>")
                            )
                    ), User.class);
            searchResponse.hits().hits().forEach(x -> System.out.println(x.source()));*/

            //分组操作
            /*SearchResponse<Map> search = client
                    .search(_0 -> _0
                            .aggregations("ageGroup", _1 -> _1
                                    .terms(_2 -> _2
                                            .field("age")
                                    )
                            ), Map.class);
            System.out.println(search);*/
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                client.shutdown();
                transport.close();
                restClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

制作不易，请尊重作者的劳动成果

amo丶
关注
  • 11
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 18
    评论
专栏目录
elasticsearch java操作的api实例
09-29
包含所因的索引建立、删除、查看，批量创建索引；搜索Query、过滤器 、分组高亮显示；以及创建Mapping
Java操作ElasticSearch工具类【支持5.0+以上所有版本】
09-30
java操作ElasticSearch的工具类。需要添加依赖： <!-- ElasticSearch依赖 --> <dependency> <groupId>io.searchbox</groupId> <artifactId>jest</artifactId> <version>6.3.1</version> </dependency> ...
Elasticsearch：使用 Elasticsearch Java client 8.0 来连接带有 HTTPS 的集群
Elastic 中国社区官方博客
04-18 6675
在我之前的教程 “Elasticsearch：使用最新的 Elasticsearch Java client 8.0 来创建索引并搜索”，我详述了如何使用 Java client 8.0 来连接一个 Elasticsearch 8.x 的集群。在那个例子中，我们的 Elasticsearch 集群是不带有 HTTPS 的安全设置的。在 Elasticsearch 8.x 的安装中，HTTPS 的配置是默认的，而且它的证书是自签名的。我们该如何修改我们的 Java 客户端代码来进行含有证书的连接呢？ 如果你
1、初始ElasticSearch-最新版Spring Boot整合ElasticSearch 8.0.1使用最新的Elasticsearch Java API Client
anyubo的博客
03-31 3960
前言 在Elasticsearch7.15版本之后，Elasticsearch官方将它的高级客户端RestHighLevelClient标记为弃用状态。同时推出了全新的Java API客户端Elasticsearch Java API Client，该客户端也将在Elasticsearch8.0及以后版本中成为官方推荐使用的客户端。 Elasticsearch Java API Client 支持除 Vector tile search API 和 Find structure API 之外的所有 Elas
Java整合ElasticSearch8.13
最新发布
galaxyou的博客
04-05 680
整合ES
Elasticsearch：使用最新的 Elasticsearch Java client 8.0 来创建索引并搜索
Elastic 中国社区官方博客
03-30 1万+
这篇文章，我来详细地描述如何使用最新的 Elasticsearch Java client 8.0 来创建索引并进行搜索。最新的 Elasticsearch Java client API 和之前的不同。在之前的一些教程中，我们使用 High Level API来进行操作。在官方文档中，已经显示为 deprecated。 前提条件 Java 8 及以后的版本 一个 JSON 对象映射库，允许你的应用程序类与 Elasticsearch API 无缝集成。 Java 客户端支持 Jackson 或像
elasticsearch java api文档
SeaSky_Steven的博客
10-23 791
说明 在明确了ES的基本概念和使用方法后，我们来学习如何使用ES的Java API. 本文假设你已经对ES的基本概念已经有了一个比较全面的认识。 客户端 你可以用Java客户端做很多事情： 执行标准的index,get,delete,update,search等操作。 在正在运行的集群上执行管理任务。 但是，通过官方文档可以得知，现在存在至少三种Java客户端。 Transport C...
elasticsearch8.0 java客户端 ＜一＞
u013979493的博客
02-24 4821
elasticsearch8.0 java连接客户端 <一>前言elasticsearch8.0 java连接客户端java连接es8.0es8.0创建索引es8.0获取索引es8.0删除索引es8.0创建doc 前言 本人在学习elasticsearch8.0时，因elasticsearch8.0缺少java文档，自己在摸索中学习es8.0 java。 elasticsearch8.0 java连接客户端 首先在es官网下载8.0，安装后，使用java调用es报错连接超时，es中提示 rece
SpringBoot 整合 Elasticsearch8.0（最新API——Java API Client for Elasticsearch）—— 2、文档操作
m0_51976820的博客
04-10 3439
SpringBoot 整合 Elasticsearch8.0（最新API——Java API Client for Elasticsearch）—— 2、文档操作
Elasticsearch8.0版本中Elasticsearch Java API Client客户端的基本使用方法
热门推荐
无枫的博客，分享Java及Vue方向的技术文章
03-10 1万+
关于Elasticsearch Java API Client客户端如何连接以及如何对索引和文档进行基本的增删改查操作请查看我的上一篇博文：Elasticsearch RestHighLevelClient 已标记为被弃用 它的替代方案 Elasticsearch Java API Client 的基础教程及迁移方案_无枫的博客，分享Java及Vue方向的技术文章-CSDN博客 本篇主要描述在Elasticsearch Java API Client客户端中如何进行批量操作，以及如何进行各种条件及类..
JavaApi操作ElasticSearch（强烈推荐）
小赵的博客
03-08 6277
单点的elasticsearch存在哪些可能出现的问题呢？单台机器存储容量有限单服务器容易出现单点故障，无法实现高可用单服务的并发处理能力有限所以，为了应对这些问题，我们需要对elasticsearch搭建集群集群：多个人做一样的事。分布式：多个人做不一样的事让系统高可用分担请求压力分担存储和计算的压力，提速解耦集群和分布式架构往往是并存的。
java操作elasticsearch api实现索引及文档增删改查（非常全面）
小米吃辣椒的博客
04-29 4222
在实际的项目开发中，我们经常要对大批量的业务数据或者日志数据进行全文检索查询，这个时候我们就可以用elasticsearch作为我们的全文检索引擎，下面我们将使用java elasticsearch 的 api 实现 索引以及文档（doc）的增删改查，包括批量新增和删除，以及组合条件，聚合，分组，高亮等高级查询都会一一以代码示例展示。
Java使用Elasticsearch7x实现对word、pdft文件的全文内容检索
天青色等烟雨
08-06 5421
前言，公司之前在线文档使用的Flash预览，用的es2全文检索，现在要进行项目整改，Flash现在不能用了，所以调整为KKFileView。对于ES也需要进行升级，添加IK中文分词器。所以就写了这篇文档进行总结与存档。 关于KKFileView的搭建与使用这里就不多说了，KKFileView官网基本都给出了解决方案，有一些个别的复制问题，我也在另一篇文档中写了。KKFileView在线预览初使用记录，主要解决不可复制等一些限制问题。 Elasticsearch在Java中使用 下面我贴出了已经写好工具类.
elasticsearch-6.3.0-API文档-中文版.zip
06-25
标签：elasticsearch、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
ElasticSearch Java API 中文文档
01-04
ElasticSearch Java API 中文文档 ElasticSearch Java API 中文文档
elasticsearch-6.8.3-API文档-中文版.zip
07-13
标签：elasticsearch、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
java elasticsearch操作(一): 连接elasticsearch8.x
qq_28548825的博客
09-27 3196
java操作elasticsearch的博文很多，大多都是复制粘贴，要不就是过时，抄来抄去没啥意思，所以这个系列就简单记录一下。参数一目了然，是https就在后面加个https即可。很简单吧，把IP和端口代入即可，具体源码就不展开了。csdn博主: liming10101010原创。
java 查询转对象_在ElasticSearch中将SearchHit转换为Java对象
weixin_42347739的博客
03-05 4760
我正在尝试检索数据表单ES查询，我对如何将每次检索到的数据转换为Java对象感到困惑。 到现在为止，我可以使用Gson获取每个JSON格式的命中，但我认为从命中转换为JSON然后转换为Java对象是没有用的。在ElasticSearch中将SearchHit转换为Java对象我当前的代码是：TransportClient client = new PreBuiltTransportClient(S...
Java客户端操作elasticsearch--添加文档
学亮编程手记
10-11 635
初始化client: 添加文档: 第二种方式：将pojo转换成json
<dependency> <groupId>co.elastic.clients</groupId> <artifactId>elasticsearch-java</artifactId> <version>8.2.0</version> </dependency>
06-03
这是一个 Maven 项目的依赖配置，它指定了 ElasticSearch 的 Java 客户端库的版本号为 8.2.0，可以被引入到项目中使用。 Maven 是一个项目管理工具，它能够自动下载和管理项目所依赖的库。ElasticSearch 是一个基于 Lucene 的搜索引擎，它可以分布式地存储、搜索和分析大量的数据。Java 客户端库可以让开发者在 Java 程序中方便地使用 ElasticSearch 的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值