java与es8实战之四：SpringBoot应用中操作es8(无安全检查)

转x33g5p2x  于2022-07-04 转载在 Java  
字(12.8k)|赞(0)|评价(0)|浏览(939)

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

本篇概览

  • 本篇是《java与es8实战》系列的第四篇，系列文章写到现在，连个HelloWorld都没运行起来，实在说不过去了…
  • 因此，本篇总体目标明确：实战在SpringBoot应用中操作elasticsearch8
  • 为了降低难度，本篇部署的elasticsearch8未设置安全检查，无需证书、账号、密码，只要连接到es的IP和端口就能执行操作
  • 总体目标可以拆解为两个子任务
  1. 在SpringBoot中连接elasticsearch8
  2. 在SpringBoot中使用elasticsearch8官方的Java API Client
  • 接下来直接开始

部署elasticsearch集群(无安全检查)

Java应用连接elasticsearch的核心套路

  • 不论是直连，还是带安全检查的连接，亦或是与SpringBoot的集成使之更方便易用，都紧紧围绕着一个不变的核心套路，该套路由两部分组成，掌握了它们就能在各种条件下成功连接es
  1. 首先，是builder pattern，连接es有关的代码，各种对象都是其builder对象的build方法创建的，建议您提前阅读《java与es8实战之一》一文，看完后，满屏的builder代码可以从丑变成美…
  2. 其次，就是java应用能向es发请求的关键：ElasticsearchClient对象，该对象的创建是有套路的，如下图，先创建RestClient，再基于RestClient创建ElasticsearchTransport，最后基于ElasticsearchTransport创建ElasticsearchClient，这是个固定的套路，咱们后面的操作都是基于此的，可能会加一点东西，但不会改变流程和图中的对象

  • 准备完毕，开始写代码

新建子工程

  • 为了便于管理依赖库版本和源码，《java与es8实战》系列的所有代码都以子工程的形式存放在父工程elasticsearch-tutorials中
  • 《java与es8实战之二：实战前的准备工作》一文说明了创建父工程的详细过程
  • 在父工程elasticsearch-tutorials中新建名为basic-crud的子工程，其pom.xml内容如下
  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <!-- 请改为自己项目的parent坐标 -->
  6.     <parent>
  7.         <artifactId>elasticsearch-tutorials</artifactId>
  8.         <groupId>com.bolingcavalry</groupId>
  9.         <version>1.0-SNAPSHOT</version>
  10.         <relativePath>../pom.xml</relativePath>
  11.     </parent>
  12.     <modelVersion>4.0.0</modelVersion>
  13.     <!-- 请改为自己项目的artifactId -->
  14.     <artifactId>basic-crud</artifactId>
  15.     <packaging>jar</packaging>
  16.     <!-- 请改为自己项目的name -->
  17.     <name>basic-crud</name>
  18.     <url>https://github.com/zq2599</url>
  20.     <!--不用spring-boot-starter-parent作为parent时的配置-->
  21.     <dependencyManagement>
  22.         <dependencies>
  23.             <dependency>
  24.                 <groupId>org.springframework.boot</groupId>
  25.                 <artifactId>spring-boot-dependencies</artifactId>
  27.                 <version>${springboot.version}</version>
  28.                 <type>pom</type>
  29.                 <scope>import</scope>
  30.             </dependency>
  31.         </dependencies>
  32.     </dependencyManagement>
  34.     <dependencies>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-actuator</artifactId>
  38.         </dependency>
  40.         <!-- 不加这个，configuration类中，IDEA总会添加一些提示 -->
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-configuration-processor</artifactId>
  44.             <optional>true</optional>
  45.         </dependency>
  47.         <dependency>
  48.             <groupId>org.projectlombok</groupId>
  49.             <artifactId>lombok</artifactId>
  50.         </dependency>
  52.         <dependency>
  53.             <groupId>org.springframework.boot</groupId>
  54.             <artifactId>spring-boot-starter-web</artifactId>
  55.         </dependency>
  57.         <dependency>
  58.             <groupId>org.springframework.boot</groupId>
  59.             <artifactId>spring-boot-starter-test</artifactId>
  60.             <scope>test</scope>
  62.             <!-- exclude junit 4 -->
  63.             <exclusions>
  64.                 <exclusion>
  65.                     <groupId>junit</groupId>
  66.                     <artifactId>junit</artifactId>
  67.                 </exclusion>
  68.             </exclusions>
  70.         </dependency>
  72.         <!-- junit 5 -->
  73.         <dependency>
  74.             <groupId>org.junit.jupiter</groupId>
  75.             <artifactId>junit-jupiter-api</artifactId>
  76.             <scope>test</scope>
  77.         </dependency>
  79.         <dependency>
  80.             <groupId>org.junit.jupiter</groupId>
  81.             <artifactId>junit-jupiter-engine</artifactId>
  82.             <scope>test</scope>
  83.         </dependency>
  85.         <!-- elasticsearch引入依赖  start -->
  86.         <dependency>
  87.             <groupId>co.elastic.clients</groupId>
  88.             <artifactId>elasticsearch-java</artifactId>
  89.         </dependency>
  91.         <dependency>
  92.             <groupId>com.fasterxml.jackson.core</groupId>
  93.             <artifactId>jackson-databind</artifactId>
  94.         </dependency>
  96.         <!-- 使用spring boot Maven插件时需要添加该依赖 -->
  97.         <dependency>
  98.             <groupId>jakarta.json</groupId>
  99.             <artifactId>jakarta.json-api</artifactId>
  100.         </dependency>
  102.         <dependency>
  103.             <groupId>org.springframework.boot</groupId>
  104.             <artifactId>spring-boot-starter-web</artifactId>
  105.         </dependency>
  106.     </dependencies>
  108.     <build>
  109.         <plugins>
  110.             <!-- 需要此插件，在执行mvn test命令时才会执行单元测试 -->
  111.             <plugin>
  112.                 <groupId>org.apache.maven.plugins</groupId>
  113.                 <artifactId>maven-surefire-plugin</artifactId>
  114.                 <version>3.0.0-M4</version>
  115.                 <configuration>
  116.                     <skipTests>false</skipTests>
  117.                 </configuration>
  118.             </plugin>
  120.             <plugin>
  121.                 <groupId>org.springframework.boot</groupId>
  122.                 <artifactId>spring-boot-maven-plugin</artifactId>
  123.                 <configuration>
  124.                     <excludes>
  125.                         <exclude>
  126.                             <groupId>org.projectlombok</groupId>
  127.                             <artifactId>lombok</artifactId>
  128.                         </exclude>
  129.                     </excludes>
  130.                 </configuration>
  131.             </plugin>
  132.         </plugins>
  134.         <resources>
  135.             <resource>
  136.                 <directory>src/main/resources</directory>
  137.                 <includes>
  138.                     <include>**/*.*</include>
  139.                 </includes>
  140.             </resource>
  141.         </resources>
  142.     </build>
  143. </project>

编码：配置文件

  • 先准备好配置文件application.yml，内容如下，很简单，只有es的地址信息
  1. elasticsearch:
  2.   # 多个IP逗号隔开
  3.   hosts: 127.0.0.1:9200

编码：配置类

  • 首先把启动类写好，平平无奇的启动类BasicCrudApplication.java
  1. @SpringBootApplication
  2. public class BasicCrudApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(BasicCrudApplication.class, args);
  5.     }
  6. }
  • 然后是配置类ClientConfig.java，这是本篇的关键，操作ES所需的ElasticsearchClient实例如何创建，ES的IP地址如何传入，全部写在这里了
  1. package com.bolingcavalry.basic.config;
  3. import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
  4. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  5. import co.elastic.clients.json.jackson.JacksonJsonpMapper;
  6. import co.elastic.clients.transport.rest_client.RestClientTransport;
  7. import lombok.Setter;
  8. import org.apache.http.HttpHost;
  9. import org.elasticsearch.client.RestClient;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.util.StringUtils;
  15. @ConfigurationProperties(prefix = "elasticsearch") //配置的前缀
  16. @Configuration
  17. public class ClientConfig {
  19.     @Setter
  20.     private String hosts;
  22.     /**
  23.      * 解析配置的字符串，转为HttpHost对象数组
  24.      * @return
  25.      */
  26.     private HttpHost[] toHttpHost() {
  27.         if (!StringUtils.hasLength(hosts)) {
  28.             throw new RuntimeException("invalid elasticsearch configuration");
  29.         }
  31.         String[] hostArray = hosts.split(",");
  32.         HttpHost[] httpHosts = new HttpHost[hostArray.length];
  33.         HttpHost httpHost;
  34.         for (int i = 0; i < hostArray.length; i++) {
  35.             String[] strings = hostArray[i].split(":");
  36.             httpHost = new HttpHost(strings[0], Integer.parseInt(strings[1]), "http");
  37.             httpHosts[i] = httpHost;
  38.         }
  40.         return httpHosts;
  41.     }
  43.     @Bean
  44.     public ElasticsearchClient elasticsearchClient() {
  45.         HttpHost[] httpHosts = toHttpHost();
  46.         RestClient restClient = RestClient.builder(httpHosts).build();
  47.         RestClientTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
  48.         return new ElasticsearchClient(transport);
  49.     }
  51.     @Bean
  52.     public ElasticsearchAsyncClient elasticsearchAsyncClient() {
  53.         HttpHost[] httpHosts = toHttpHost();
  54.         RestClient restClient = RestClient.builder(httpHosts).build();
  55.         RestClientTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
  56.         return new ElasticsearchAsyncClient(transport);
  57.     }
  58. }
  • 从上面的代码可以看出，配置类已经向Spring容器注册了ElasticsearchClient实例，后面的业务都可以使用此实例来操作ES

编码：服务类

  • 本篇只是为了演示SpringBoot应用如何连接和操作ES，还不会深入ES操作的细节，因此只对索引做一些基本操作即可
  • 先写一个接口IndexService.java，里面定义了多个索引操作的方法
  1. package com.bolingcavalry.basic.service;
  3. import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
  4. import co.elastic.clients.elasticsearch.indices.IndexSettings;
  5. import co.elastic.clients.util.ObjectBuilder;
  7. import java.io.IOException;
  8. import java.util.function.Function;
  10. public interface IndexService {
  12.     /**
  13.      * 新建指定名称的索引
  14.      * @param name
  15.      * @throws IOException
  16.      */
  17.     void addIndex(String name) throws IOException;
  19.     /**
  20.      * 检查指定名称的索引是否存在
  21.      * @param name
  22.      * @return
  23.      * @throws IOException
  24.      */
  25.     boolean indexExists(String name) throws IOException;
  27.     /**
  28.      * 删除指定索引
  29.      * @param name
  30.      * @throws IOException
  31.      */
  32.     void delIndex(String name) throws IOException;
  34.     /**
  35.      * 创建索引，指定setting和mapping
  36.      * @param name 索引名称
  37.      * @param settingFn 索引参数
  38.      * @param mappingFn 索引结构
  39.      * @throws IOException
  40.      */
  41.     void create(String name,
  42.                 Function<IndexSettings.Builder, ObjectBuilder<IndexSettings>> settingFn,
  43.                 Function<TypeMapping.Builder, ObjectBuilder<TypeMapping>> mappingFn) throws IOException;
  44. }
  • 然后接口的实现，可见所有操作都是在调用ElasticsearchClient实例的API
  1. package com.bolingcavalry.basic.service.impl;
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
  5. import co.elastic.clients.elasticsearch.indices.IndexSettings;
  6. import co.elastic.clients.util.ObjectBuilder;
  7. import com.bolingcavalry.basic.service.IndexService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.context.ApplicationContext;
  10. import org.springframework.stereotype.Service;
  12. import java.io.IOException;
  13. import java.util.function.Function;
  15. @Service
  16. public class IndexServiceImpl implements IndexService {
  18.     @Autowired
  19.     private ElasticsearchClient elasticsearchClient;
  21.     @Override
  22.     public void addIndex(String name) throws IOException {
  23.         ApplicationContext applicationContext;
  24.         elasticsearchClient.indices().create(c -> c.index(name));
  25.     }
  27.     @Override
  28.     public boolean indexExists(String name) throws IOException {
  29.         ApplicationContext a;
  30.         return elasticsearchClient.indices().exists(b -> b.index(name)).value();
  31.     }
  33.     @Override
  34.     public void delIndex(String name) throws IOException {
  35.         elasticsearchClient.indices().delete(c -> c.index(name));
  36.     }
  38.     @Override
  39.     public void create(String name,
  40.                        Function<IndexSettings.Builder, ObjectBuilder<IndexSettings>> settingFn,
  41.                        Function<TypeMapping.Builder, ObjectBuilder<TypeMapping>> mappingFn) throws IOException {
  42.        elasticsearchClient
  43.                .indices()
  44.                .create(c -> c
  45.                        .index(name)
  46.                        .settings(settingFn)
  47.                        .mappings(mappingFn)
  48.                );
  49.     }
  50. }
  • 以上就是本篇的功能代码了，连接ES在其上进行索引相关操作

编码：单元测试

  • 为了验证上述代码是否生效，接下来写一个单元测试类IndexServiceTest.java，可以重点关注createIndex方法，里面演示了Builder pattern构建参数的详细步骤
  1. package com.bolingcavalry.basic.service;
  3. import co.elastic.clients.elasticsearch._types.mapping.Property;
  4. import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
  5. import co.elastic.clients.elasticsearch.indices.IndexSettings;
  6. import co.elastic.clients.util.ObjectBuilder;
  7. import org.junit.jupiter.api.Assertions;
  8. import org.junit.jupiter.api.Test;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.boot.test.context.SpringBootTest;
  12. import java.util.function.Function;
  14. @SpringBootTest
  15. class IndexServiceTest {
  17.     @Autowired
  18.     IndexService indexService;
  20.     @Test
  21.     void addIndex() throws Exception {
  22.         String indexName = "test_index";
  24.         Assertions.assertFalse(indexService.indexExists(indexName));
  25.         indexService.addIndex(indexName);
  26.         Assertions.assertTrue(indexService.indexExists(indexName));
  27.         indexService.delIndex(indexName);
  28.         Assertions.assertFalse(indexService.indexExists(indexName));
  29.     }
  31.     @Test
  32.     void indexExists() throws Exception {
  33.         indexService.indexExists("a");
  34.     }
  36.     @Test
  37.     void createIndex() throws Exception {
  38.         // 索引名
  39.         String indexName = "product002";
  41.         // 构建setting时，builder用到的lambda
  42.         Function<IndexSettings.Builder, ObjectBuilder<IndexSettings>> settingFn = sBuilder -> sBuilder
  43.                 .index(iBuilder -> iBuilder
  44.                         // 三个分片
  45.                         .numberOfShards("3")
  46.                         // 一个副本
  47.                         .numberOfReplicas("1")
  48.                 );
  50.         // 新的索引有三个字段，每个字段都有自己的property，这里依次创建
  51.         Property keywordProperty = Property.of(pBuilder -> pBuilder.keyword(kBuilder -> kBuilder.ignoreAbove(256)));
  52.         Property textProperty = Property.of(pBuilder -> pBuilder.text(tBuilder -> tBuilder));
  53.         Property integerProperty = Property.of(pBuilder -> pBuilder.integer(iBuilder -> iBuilder));
  55.         // // 构建mapping时，builder用到的lambda
  56.         Function<TypeMapping.Builder, ObjectBuilder<TypeMapping>> mappingFn = mBuilder -> mBuilder
  57.                 .properties("name", keywordProperty)
  58.                 .properties("description", textProperty)
  59.                 .properties("price", integerProperty);
  61.         // 创建索引，并且指定了setting和mapping
  62.         indexService.create(indexName, settingFn, mappingFn);
  63.     }
  64. }
  • 确保不做安全检查的ES集群运行正常，再执行单元测试，如下图，顺利通过，证明所有对ES的操作都符合预期

  • 再用eshead观察product002索引的情况，如下图，三个分片，一个副本，与代码中设置的一致

  • 至此最简单的连接和操作ES实战已经完成，希望本篇能给您一些参考，助您顺利完成基本操作

是不是线程安全的

  • 官方回应：https://discuss.elastic.co/t/is-elasticsearch-client-is-thread-safe/151745
  • 有人在问这个问题，es团队的成员Simon Willnauer的回答是：java的client肯定是线程安全的，golang的不清楚

  • 对我来说，有他这话就够了，至于golang的嘛，在本文就不讨论了

源码下载

  • 本篇实战的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)
名称链接备注
项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页
git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议
git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议
  • 这个git项目中有多个文件夹，本次实战的源码在elasticsearch-tutorials文件夹下，如下图红框

  • elasticsearch-tutorials是个父工程，里面有多个module，本篇实战的module是basic-crud，如下图红框

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://xinchen.blog.csdn.net/article/details/125589598

内容来源于网络，如有侵权，请联系作者删除！

Javajava服务端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com