SpringBoot2.2.5自动装配分析及手动实现

最新推荐文章于 2024-07-28 20:16:02 发布
最新推荐文章于 2024-07-28 20:16:02 发布
阅读量929 收藏 2
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dgatiger/article/details/104994356
版权
1.新建sprigboot项目

项目pox.xml如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.demo.springboot</groupId>
    <artifactId>autoconfig-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>autoconfig-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

除了项目的GAV之外都是默认的。

2.自撸基本思路

SpringBoot启动类，默认是@SpringBootApplication注解，而该注解主要有三个注解构成，即：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan。

各注解的作用参考官方文档"3.6. Using the @SpringBootApplication Annotation"

参考对标@EnableAutoConfiguration注解，我们可以理出如下思路：

  • 该注解首先通过@Import导入AutoConfigurationImportSelector.class
@Import(AutoConfigurationImportSelector.class)
  • AutoConfigurationImportSelector的核心函数selectImports调用getAutoConfigurationEntry,返回的是String[]。
	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
				annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}
  • 跟进getAutoConfigurationEntry函数，核心调用的是getCandidateConfigurations。
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = filter(configurations, autoConfigurationMetadata);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}
  • 继续跟进getCandidateConfigurations,核心调用的是SpringFactoriesLoader.loadFactoryNames。
	/**
	 * Return the auto-configuration class names that should be considered. By default
	 * this method will load candidates using {@link SpringFactoriesLoader} with
	 * {@link #getSpringFactoriesLoaderFactoryClass()}.
	 * @param metadata the source metadata
	 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
	 * attributes}
	 * @return a list of candidate configurations
	 */
	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you " + "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}
  • 继续跟进SpringFactoriesLoader.loadFactoryNames,loadFactoryNames调用楼下的loadSpringFactories，返回的结果再链式调用getOrDefault，真正干活的出现了，就是loadSpringFactories！
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		String factoryTypeName = factoryType.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

这里重点先看下面代码，即若classLoader参数不为空，就是说有传类加载器进来，而在本例中其实就是AutoConfigurationImportSelector的类加载器。

Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));

若有传如类加载器进来就获得本类所在的资源文件，否则获得系统的资源文件，即"Finds all resources of the specified name from the search path used to load classes."
本例中传入的是org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.class的类加载器，所以自然就是找该类所在的包里的资源文件。

常量FACTORIES_RESOURCE_LOCATION = “META-INF/spring.factories”

这样就真相大白了，原来springboot的autoconfigure，其实就是让SpringFactoriesLoader去加载指定类所在位置的资源文件！

接下来我们看看org.springframework.boot.autoconfigure包里的spring.factories文件

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
中间省略N行...总共有100+行
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

# Failure analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
org.springframework.boot.autoconfigure.flyway.FlywayMigrationScriptMissingFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer,\
org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer

# Template availability providers
org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.mustache.MustacheTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.web.servlet.JspTemplateAvailabilityProvider

特别注意# Auto Configure部分有个

org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider

的键，说明这个键跟后面100多个类有关联。

接着看代码，发现loadSpringFactories将将配置文件加载进来，生成一个MultiValueMap，放入缓存并返回。

接着看链式调用的getOrDefault函数，逻辑简单说就是以传入的类名为参数，返回的MultiValueMap类型变量中存在以本类名为键值的就返回对应的类List，否则返回空List。

最终，这个List返回给了selectImports，然后交由org.springframework.beans.factory.support.DefaultListableBeanFactory通过反射生成一个又一个的单例对象，类的自动扫描装配到此结束。

3.依葫芦画瓢
3.1 建立自动装配注解@DemoEnableAutoConfig
package com.demo.springboot.autoconfigdemo.autoconfig;

import org.springframework.context.annotation.Import;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author : Alex Hu
 * date : 2020/3/20 下午13:27
 * description : 自定义个注解，模拟springboot的@EnableAutoConfiguration
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(value = {AutoConfigurationImportSelector.class})
public @interface DemoEnableAutoConfig {
}
3.2 实现AutoConfigurationImportSelector.class
package com.demo.springboot.autoconfigdemo.autoconfig;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * @author : Alex Hu
 * date : 2020/3/20 上午08:55
 * description : springboot 自动装配方式，从properties文件批量导入
 */
public class AutoConfigurationImportSelector implements ImportSelector {
    //返回注解的class, META-INF/spring.factories 中的键名
    private Class<?> getSpringFactoriesLoaderFactoryClass() {
        return DemoEnableAutoConfig.class;
    }

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        List<String> configurations = getCandidateConfigurations();
        System.out.println("configurations: " + configurations);
        return StringUtils.toStringArray(configurations);
    }


    protected List<String> getCandidateConfigurations() {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                //返回注解类的class
                getSpringFactoriesLoaderFactoryClass(),
                //当前类的classloader
                this.getClass().getClassLoader()
        );
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. " +
                "If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

}
3.3 建立配置文件

文件位于resources/META-INF/目录，文件名spring.factories

com.demo.springboot.autoconfigdemo.autoconfig.DemoEnableAutoConfig=\
com.demo.springboot.autoconfigdemo.classes.ClassA,\
com.demo.springboot.autoconfigdemo.classes.ClassB

表示扫描ClassA与ClassB这两个类

3.4 修改启动程序
package com.demo.springboot.autoconfigdemo;

import com.demo.springboot.autoconfigdemo.autoconfig.DemoEnableAutoConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author Alex Hu
 */
@DemoEnableAutoConfig
//@ComponentScan
public class AutoconfigDemoApplication {

    public static void main(String[] args) {
      SpringApplication.run(AutoconfigDemoApplication.class, args);
    }

}
3.5 检查成果

运行启动程序，结果如下：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.5.RELEASE)

2020-03-20 17:04:50.745  INFO 18192 --- [           main] c.d.s.a.AutoconfigDemoApplication        : Starting AutoconfigDemoApplication on huqiupingdeMacBook-Pro.local with PID 18192 (/Users/alexhu/IdeaProjects/autoconfig-demo/target/classes started by alexhu in /Users/alexhu/IdeaProjects/boot-demo)
2020-03-20 17:04:50.747  INFO 18192 --- [           main] c.d.s.a.AutoconfigDemoApplication        : No active profile set, falling back to default profiles: default
configurations: [com.demo.springboot.autoconfigdemo.classes.ClassA, com.demo.springboot.autoconfigdemo.classes.ClassB]
ClassA.ClassA  构造器被执行
ClassB.ClassB  构造器被执行
2020-03-20 17:04:50.863  INFO 18192 --- [           main] c.d.s.a.AutoconfigDemoApplication        : Started AutoconfigDemoApplication in 0.5 seconds (JVM running for 0.92)

Process finished with exit code 0

目标两个类的构造函数被执行，说明spring帮我们实例化了这两个类。

3.6 题外话

若本例中的spring.factories，配置中的键直接修改为：

org.springframework.boot.autoconfigure.EnableAutoConfiguration

启动程序的注解直接用系统自带的@EnableAutoConfiguration，又会是什么结果？大家可以先猜，猜完可以再试 ^ _^

4.总结

其实SpringBoot的自动装配核心内容并不复杂，调试跟进源代码是法宝。
本演示项目源代码在这里

gzJustCoding
关注
专栏目录
springboot自动装配
木头人i
02-25 595
springboot自动装配
SpringBoot——优势与自动装配原理
sduihoal的博客
05-27 709
一、SpringBoot自动装配原理 二、SpringBoot的配置 1. SpringBoot推荐使用.yaml来配置，与properties不同在于yml除了存储键值对外还可以存储对象。 三、
SpringBoot自动装配的应用
weixin_41979002的博客
05-12 1054
一、什么是自动装配 在使用SpringBoot的时候，会自动将Bean装配到IoC容器中。例如我们在使用Redis数据库的时候，会引入依赖spring-boot-starter-data-redis。在引入这个依赖后，服务初始化的时候，会将操作Redis需要的组件注入到IoC容器中进行后续使用 自动装配大致过程如下： 1）通过注解@SpringBootApplication=>@EnableAutoConfiguration=>@Import({AutoConfigurationImportS
SpringBoot自动装配
最新发布
爱敲代码的三毛的博客
07-28 1188
SpringBoot自动装配
spring boot 入门_Spring Boot 2.2.5 尝鲜-入门指南
weixin_39620037的博客
11-20 191
如果您是"Spring Boot"或“Spring”新手，那么可通过本章来入门.本章回答了基本的“what?”, “how?” and “why?”等问题，并包含Spring Boot介绍，安装说明等内容.之后，我们将引导您构建第一个Spring Boot 应用程序，并讨论它的一些核心概念.1. Spring Boot介绍Spring Boot可轻松创建独立且生产级的Spring应用程序.为方便您...
Springboot自动装配的实现流程
cocoawork 丶的博客
10-16 942
带着这个问题到网上搜索，大多数文章在解释这个问题的时候，上来就是@SpringBootApplication注解中找@EnableAutoConfiguration注解，然后找到@Import(AutoConfigurationImportSelector.class)注解，然后就到AutoConfigurationImportSelector类中找，惊呆????~ 不过也没错，最后确实是因为这个注解这个类完成的自动装配，但是Spring是如何从开始的注解一步一步完成自动装配的呢？ 接下来一步一步的调试跟
SpringBoot自动装配探究
菜鸟清风http://www.hphblog.cn/
03-28 217
Spring Boot自动配置的探究 ： 参考配置文件能配置的属性参照 原理SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration 作用 利用EnableAutoConfigurationImportSelector给容器中导入一些组件 查看selectImports()方法的内...
Springboot学习笔记
大湿的学徒的博客
09-11 432
文章目录1. SpringBoot框架入门1.1 SpringBoot简介1.2 SpringBoot特点1.3 SpringBoot的四大特性 1. SpringBoot框架入门 1.1 SpringBoot简介 Spring Boot是Spring家族中一个全新的框架, 用来简化Spring应用程序的创建和开发过程, 能够简化我们之前采用Spring+SpringMVC+Mybatis框架进行开发的过程。 1.2 SpringBoot特点 能够快速创建基于Spring的应用程序 能够使用main方法启
autoconfig-demo.zip
03-20
手动实现springboot 2.2.5 启动自动装配演示代码 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0 <groupId>org.spring...
SpringBoot
thebss的博客
04-13 1671
1.运行原理 自动配置 ①自动配置的东西都在springboot-autoconfigure的jar包中； ②自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作； ④springboot的所有自动装配都是在启动时扫描并加载:所有的自动配置类都在spring.factories文件中，只要导入了对应的starter启动器就会生效 2.yaml 这种语言以数据作为中心，而不是以标记语言
狂神说SpringBoot05：自动配置原理
狂神说
03-12 6656
狂神说SpringBoot系列连载课程，通俗易懂，基于SpringBoot2.2.5版本，欢迎各位狂粉转发关注学习。未经作者授权，禁止转载自动配置原理配置文件到底能写什么？怎么写？Spr...
Springboot2——自动装配原理
Yellow_Star的博客
11-09 429
引导加载配置类原理 SpringBoot是通过@SpringBootApplication启动的，在上一章节的学习中，发现启动之后，除了我们自己添加到IOC容器中的组件，还有另外一些组件被自动的添加到IOC容器中，我们猜测是通过这个注解添加的，我们先来看一下@SpringBootApplication @SpringBootApplication @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilt
SpringBoot 2.2.5
qq_45536740的博客
06-28 670
Spring Boot(2020版) 1. springboot的引言 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的 初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不 再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应 用开发领域(rapid application development)成为领导者。 springboot(微框架) = springmvc(控制器) + spring core(
SpringBoot自动装配原理，这一篇就够了！
热门推荐
CC_且听风吟丶的博客
05-08 8万+
有关SpringBoot自动装配原理，你需要知道的一切。
spring boot学习二：Spring Boot自动装配分析与实战
ytq007的博客
10-05 698
上文中简单介绍了intellij环境下Spring Boot的入门示例，从而见识到了Spring Boot的强大，几乎不用做什么配置，就能运行一个Spring mvc的示例，要知道，Spring之前都是以繁琐的配置而为人诟病，Spring Boot的自动装配，可以根据pom的依赖配置，自动生成相应的bean，并加载到Spring Context中，简化了Spring项目搭建的复杂度，本节主要介...
Springboot如何实现自动装配
a429095958的博客
05-21 530
Springboot如何实现自动装配 首先附上springboot启动的整理流程图，可以发现实现自动装配的主要是里面的两个流程prepareContext(）和refreshContext（）。 下面就让我们进入这两个方法，去分析spring如何完成自动装配。 prepareContext（） prepareContext里面的核心方法是load(context, sources.toArray(new Object[0]));， sourcce就是我们的main函数所在的类。 创建一个loader用于
spring boot自动装配功能的实现
weixin_42877425的博客
01-23 497
1. 在启动类上使用@EnableAutoConfiguration注解，激活spring boot的自动化配置 @EnableAutoConfiguration public class AutoConfigBoot { public static void main(String[] args) { ConfigurableApplicationContext context = new SpringApplicationBuilder(AutoConfigBoot.class)
SpringBoot-2.2.5入门-环境配置-程序启动-配置文件加载
mr_fan的博客
03-17 770
springboot项目之HelloWord 主程序入口 自动配置原理简介 配置文件加载简介 yml语法简介
springboot2.2.5 整合 es
08-20
你好！对于Spring Boot 2.2.5与Elasticsearch的整合，你可以按照以下步骤进行操作： 1. 在pom.xml文件中添加Elasticsearch的依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> ``` 2. 创建一个Elasticsearch的配置类，比如ElasticsearchConfig.java： ```java import org.elasticsearch.client.RestHighLevelClient; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.elasticsearch.client.ClientConfiguration; import org.springframework.data.elasticsearch.client.RestClients; import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration; @Configuration public class ElasticsearchConfig extends AbstractElasticsearchConfiguration { @Value("${elasticsearch.host}") private String host; @Value("${elasticsearch.port}") private int port; @Override @Bean public RestHighLevelClient elasticsearchClient() { final ClientConfiguration clientConfiguration = ClientConfiguration.builder() .connectedTo(host + ":" + port) .build(); return RestClients.create(clientConfiguration).rest(); } } ``` 3. 在应用的配置文件（如application.properties或a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值