So konfigurieren Sie die SpringBoot-Externalisierung
- WBOYnach vorne
- 2023-05-15 09:43:051162Durchsuche
Externalisierte SpringBoot-Konfiguration (basierend auf 2.4.0 und höher)
Mit Spring Boot können Sie die Konfiguration externalisieren, sodass Sie denselben Anwendungscode in verschiedenen Umgebungen verwenden können. Sie können eine Vielzahl externer Konfigurationsquellen verwenden, darunter Java-Eigenschaftendateien, YAML-Dateien, Umgebungsvariablen und Befehlszeilenparameter.
Eigenschaftswerte können mithilfe der @Value-Annotation direkt in Ihre Beans eingefügt, über die Spring-Umgebung abgerufen oder über @ConfigurationProperties an Objekte gebunden werden. Gleichzeitig bietet Spring Boot auch eine ganz besondere PropertyOrder, mit der Benutzer bestimmte Eigenschaftswerte in geeigneten Szenarien überschreiben können. Diese Reihenfolge soll ein sinnvolles Überschreiben von Werten ermöglichen.
Die Priorität ist von niedrig nach hoch in der folgenden Reihenfolge, der Eigenschaftswert des letzteren überschreibt den ersteren und alle Konfigurationen bilden komplementäre Konfigurationen:
Standardeigenschaften (angegeben mit SpringApplication.setDefaultProperties)
@Configuration Konfigurationseigenschaften, die durch die Annotation @PropertySource für die Klasse eingeführt werden@Configuration类上的@PropertySource注解引入的配置属性
请注意，这样的属性源直到ApplicationContext被刷新时才会被添加到环境中。这对于配置某些属性来说已经太晚了，比如logging.* 和spring.main.* ，它们在刷新开始前就已经被读取了。
配置数据（例如application.properties文件）
对于random.*形式的属性，优先从RandomValuePropertySource获取（指优先于后者）
OS environment variables(（操作系统环境变量）
Java System properties（Java 系统属性System.getProperties()）
JNDI 属性
ServletContext 的 初始化参数
ServletConfig 的 初始化参数
SPRING_APPLICATION_JSON 属性
命令行参数
test 模块下的 properties 属性
test 模块下 @TestPropertySource 注解引入的配置文件
启用 devtools 时 $HOME/.config/spring-boot 路径下的配置
配置数据文件按以下加载顺序考虑：
打包在 jar 中的应用程序属性（application.properties 和 YAML）
打包在 jar 中的特定配置文件的应用程序属性（application-{profile}.properties 和 YAML）
打包 jar 之外的应用程序属性（application.properties 和 YAML）
打包 jar 之外的特定配置文件的应用程序属性（application-{profile}.properties 和 YAML）
SpringBoot配置文件
Spring中常见的配置文件类型
XML资源
Properties资源
YAML资源
Profile概述
Profile 本质上代表一种用于组织配置信息的维度，在不同场景下可以代表不同的含义。例如，如果 Profile 代表的是一种状态，我们可以使用 open、halfopen、close 等值来分别代表全开、半开和关闭等。再比如系统需要设置一系列的模板，每个模板中保存着一系列配置项。
配置命名规则：
/{application}.yml
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties配置文件加载顺序
Spring Boot 启动时，会自动加载 JAR 包内部及 JAR 包所在目录指定位置的配置文件（Properties 文件、YAML 文件）。列表按优先级排序（较低项目的值覆盖较早项目的值）
classpath（ –classpath ）
classpath 根路径
classpath 下的 /config 包
当前目录（ –file ）
当前目录下
当前目录下的 config/ 子目录
当前目录下的 config/ 子目录的直接子目录
. project-sample ├── config │ ├── application.yml （4） │ └── src/main/resources | │ ├── application.yml （1） | │ └── config | | │ ├── application.yml （2） ├── application.yml （3）
启动时加载配置文件顺序：1 > 2 > 3 > 4
Profile 配置覆盖变更（2.4.0以后）
2.4.0以前版本，默认情况的加载顺序如下：
打包在 jar 中的应用程序属性（application.properties 和 YAML）。
打包 jar 之外的应用程序属性（application.properties 和 YAML）
打包在 jar 中的特定于配置文件的应用程序属性（application-{profile}.properties 和 YAML）
打包 jar 之外的特定于配置文件的应用程序属性（application-{profile}.properties 和 YAML）
注意：在之前的版本中，JAR 包外部的application.properties配置文件不会覆盖 JAR 包里面的基于 "profile" 的application-{profile}.properties 配置文件。
2.4.0
ApplicationContext aktualisiert wird . Dies ist zu spät, um einige Eigenschaften wie logging.* und spring.main.* zu konfigurieren, die bereits vor Beginn der Aktualisierung gelesen wurden. - Konfigurationsdaten (z. B. application.properties-Datei) Für Eigenschaften in der Form
random.*werden sie zuerst vonRandomValuePropertySourceabgerufen (bezogen auf die Priorität gegenüber dem Letzteres) - OS-Umgebungsvariablen((Betriebssystemumgebungsvariablen)Java-Systemeigenschaften (Java-Systemeigenschaften
System.getProperties()) - JNDI-EigenschaftenInitialisierungsparameter von ServletContext🎜🎜Initialisierungsparameter von ServletConfig🎜🎜SPRING_APPLICATION_JSON-Eigenschaft 🎜🎜Befehlszeilenparameter🎜🎜properties-Attribut unter Testmodul🎜🎜Konfigurationsdatei, die durch @TestPropertySource-Annotation unter Testmodul eingeführt wurde🎜🎜Konfiguration unter $HOME/.config/spring-boot-Pfad, wenn Devtools aktiviert ist🎜🎜 Die Konfigurationsdatendatei lautet wie folgt: Überlegungen zur Ladereihenfolge: 🎜🎜🎜🎜Anwendungseigenschaften, gepackt im JAR (application.properties und YAML) 🎜🎜🎜🎜Anwendungseigenschaften eines bestimmten Profils, gepackt im JAR (application-{profile}.properties und YAML) 🎜🎜🎜🎜Anwendungseigenschaften (application.properties und YAML) außerhalb des verpackten Glases 🎜🎜🎜🎜Anwendungseigenschaften für bestimmte Profile (application-{profile}.properties und YAML) außerhalb des verpackten Glases🎜🎜 ul>🎜 SpringBoot-Konfigurationsdatei🎜
Gemeinsame Konfigurationsdateitypen in Spring
🎜🎜🎜XML-Ressourcen🎜🎜🎜🎜Eigenschaftsressourcen🎜🎜🎜🎜YAML-Ressourcen🎜🎜
Profilübersicht🎜 Profil stellt im Wesentlichen eine Dimension dar, die zum Organisieren von Konfigurationsinformationen verwendet wird, und kann in verschiedenen Szenarien unterschiedliche Bedeutungen darstellen. Wenn Profil beispielsweise einen Zustand darstellt, können wir Werte wie „offen“, „halb offen“ und „geschlossen“ verwenden , geschlossen usw. Ein weiteres Beispiel ist, dass das System eine Reihe von Vorlagen einrichten muss. Jede Vorlage speichert eine Reihe von Konfigurationselementen: 🎜spring:
profiles:
active: dev #激活开发环境配置Ladereihenfolge der Konfigurationsdatei
🎜Wenn Spring Boot startet, wird es lädt automatisch die Konfigurationsdateien (Eigenschaftsdateien, YAML-Dateien) im JAR-Paket und am angegebenen Speicherort im Verzeichnis, in dem sich das JAR-Paket befindet. Die Liste ist nach Priorität sortiert (Werte für niedrigere Elemente überschreiben Werte für frühere Elemente). 🎜🎜Unter dem aktuellen Verzeichnis🎜🎜Das config/-Unterverzeichnis im aktuellen Verzeichnis🎜🎜Das direkte Unterverzeichnis des config/-Unterverzeichnisses im aktuellen Verzeichnis🎜$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
🎜Die Reihenfolge des Ladens der Konfigurationsdateien beim Start: 1 > 2 > ; 4🎜Änderungen der Profilkonfigurationsabdeckung (nach 2.4.0)
🎜2.4.0Für frühere Versionen ist die Standardladereihenfolge wie folgt: 🎜🎜🎜🎜Anwendungseigenschaften gepackt in jar (Anwendung .properties und YAML). 🎜🎜🎜🎜Paketanwendungseigenschaften (application.properties und YAML) außerhalb des JAR 🎜🎜🎜🎜Paketprofilspezifische Anwendungseigenschaften (application-{profile}.properties und YAML) innerhalb des JAR 🎜🎜🎜 🎜Profilspezifische Anwendungseigenschaften (application-{profile}.properties und YAML) außerhalb des gepackten JAR 🎜🎜🎜Hinweis: In früheren Versionen application.properties außerhalb des JAR-Pakets Die Konfigurationsdatei überschreibt nicht das „ „profile“-basierte application-{profile}.properties-Konfigurationsdatei im JAR-Paket. 🎜🎜2.4.0 und spätere Versionen, die Standardsuchreihenfolge ist wie folgt: Sie stellt sicher, dass Anwendungsparameter außerhalb des JAR-Pakets Vorrang vor bestimmten Aktivierungskonfigurationsparametern innerhalb des JAR-Pakets haben 🎜🎜🎜🎜Verpackt in jar Anwendungseigenschaften (application.properties und YAML) in . 🎜🎜🎜🎜Profilspezifische Anwendungseigenschaften, verpackt im JAR (application-{profile}.properties und YAML) 🎜🎜🎜🎜Verpacken von Anwendungseigenschaften außerhalb des JAR (application.properties und YAML) 🎜
打包 jar 之外的特定于配置文件的应用程序属性（application-{profile}.properties 和 YAML）
注意：同一位置下，Properties 文件优先级高于 YAML 文件 ， 如果Spring Boot在优先级更高的位置找到了配置，那么它就会无视优先级低的配置。
文档排序（2.4.0以后）
从 Spring Boot 2.4 开始，加载 Properties 和 YAML 文件时候会遵循， 在文档中声明排序靠前的属性将被靠后的属性覆盖 。
激活指定配置文件
命令行激活： --spring.profiles.active=prod
spring:
profiles:
active: dev #激活开发环境配置配置文件激活如上，只需要在application.yml或者properties文件中配置即可
注意：在application.yml或者properties文件存在的情况下，不管激活的是prod还是dev，还是会读取默认的配置文件，只不过指定的配置文件会覆盖默认配置文件中的属性
导入额外的配置文件（2.4.0以后）
可以使用spring.config.import属性从其他地方导入更多的配置数据，比如spring.config.import=my.yaml 。它会将 my.yaml 文件作为临时文件放在当前配置文件之后处理，因此其属性具有更高的优先级
激活外部配置文件
在运行Jar包的命令中加入这个参数就可以指定Jar包以外的配置文件的位置了，也可以在application的配置文件中配置该属性
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
这个参数就是指定外部application.yml配置文件位置的参数，它支持classpath和file路径
java -jar myproject.jar --spring.config.name=myproject
如果您不喜欢application.properties作为配置文件名，您可以通过指定spring.config.name环境属性来切换到另一个文件名
optional可选的配置文件
对于spring.config.location、spring.config.additional-location和spring.config.import等属性的路径，添加optional:前缀，则当对应文件不存在时应用仍可以正常启动
比如spring.config.location=optional:file:/my.yaml，当应用启动加载文件 my.yaml 不存在时，不会抛出异常
嵌入系统配置信息
例如，如果想要获取当前应用程序的名称并作为一个配置项进行管理，那么很简单，我们直接通过 ${spring.application.name} 占位符：
myapplication.name : ${spring.application.name}假设我们使用 Maven 来构建应用程序，那么可以按如下所示的配置项来动态获取与系统构建过程相关的信息：
info:
app:
encoding: @project.build.sourceEncoding@
java:
source: @java.version@
target: @java.version@
# 等同于下述效果
info:
app:
encoding: UTF-8
java:
source: 1.8.0_31
target: 1.8.0_31配置参数提示
additional-spring-configuration-metadata.json、spring-configuration-metadata.json在springboot-starter官方项目或第三方starter项目中随处可见，那它起的作用是什么？
配置
additional-spring-configuration-metadata.json文件后，在开发人员的IDE工具使用个人编写的配置读取很有效的在application.properties或application.yml文件下完成提示
配置处理器
在Maven中，该依赖关系应被声明为可选的，如以下例子所示。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>创建additional-spring-configuration-metadata.json
在resources/META-INF目录下创建additional-spring-configuration-metadata.json，分类为 “groups” 或 “properties”，附加值提示分类为 "hints"，如以下例子所示：
{
"groups": [
{
"name": "server",
"type": "org.springframework.boot.autoconfigure.web.ServerProperties",
"sourceType": "org.springframework.boot.autoconfigure.web.ServerProperties"
},
{
"name": "spring.jpa.hibernate",
"type": "org.springframework.boot.autoconfigure.orm.jpa.JpaProperties$Hibernate",
"sourceType": "org.springframework.boot.autoconfigure.orm.jpa.JpaProperties",
"sourceMethod": "getHibernate()"
}
...
],
"properties": [
{
"name": "server.port",
"type": "java.lang.Integer",
"sourceType": "org.springframework.boot.autoconfigure.web.ServerProperties"
},
{
"name": "server.address",
"type": "java.net.InetAddress",
"sourceType": "org.springframework.boot.autoconfigure.web.ServerProperties"
},
{
"name": "spring.jpa.hibernate.ddl-auto",
"type": "java.lang.String",
"description": "DDL mode. This is actually a shortcut for the "hibernate.hbm2ddl.auto" property.",
"sourceType": "org.springframework.boot.autoconfigure.orm.jpa.JpaProperties$Hibernate"
}
...
],
"hints": [
{
"name": "spring.jpa.hibernate.ddl-auto",
"values": [
{
"value": "none",
"description": "Disable DDL handling."
},
{
"value": "validate",
"description": "Validate the schema, make no changes to the database."
},
{
"value": "update",
"description": "Update the schema if necessary."
},
{
"value": "create",
"description": "Create the schema and destroy previous data."
},
{
"value": "create-drop",
"description": "Create and then destroy the schema at the end of the session."
}
]
}
]
}Property 属性
properties 数组中包含的JSON对象可以包含下表中描述的属性。
Der vollständige Name des Attributs. Der Name ist in Kleinbuchstaben und durch Punkte getrennt (z. B. server.address). Dieses Attribut ist obligatorisch.| type | String | Die vollständige Signatur des Datentyps der Eigenschaft (z. B. java.lang.String), aber es gibt auch vollständige generische Typen (z. B. java.util.Map |
|---|---|---|
| Beschreibung | String | Eine kurze Beschreibung der Eigenschaft, die dem Benutzer angezeigt werden kann. Wenn keine Beschreibung vorhanden ist, kann diese weggelassen werden. Die letzte Zeile in der Beschreibung sollte mit einem Punkt (.) enden. |
| sourceType | String | Der Klassenname der Quelle, die diese Eigenschaft beigetragen hat. Wenn die Eigenschaft beispielsweise von einer mit @ConfigurationProperties annotierten Klasse stammt, enthält die Eigenschaft den vollständig qualifizierten Namen der Klasse. Kann weggelassen werden, wenn der Quelltyp unbekannt ist. |
| defaultValue | Object | Standardwert. Wenn diese Eigenschaft nicht angegeben ist, wird dieser Wert verwendet. Wenn der Typ der Eigenschaft ein Array ist, kann es sich um ein Array von Werten handeln. Wenn der Standardwert unbekannt ist, kann er weggelassen werden. |
| deprecation | Deprecation | Gibt an, ob dieses Attribut veraltet ist. Wenn dieses Feld nicht veraltet ist oder diese Informationen nicht bekannt sind, kann es weggelassen werden. Die folgende Tabelle enthält weitere Details zum Deprecation-Attribut. |
| Hint-Eigenschaften | Das im Hints-Array enthaltene JSON-Objekt kann die Eigenschaften in der folgenden Tabelle enthalten. | |
| Name | Typ | Zweck |
| values | ValueHint[] | Die Liste der gültigen Werte, die vom ValueHint-Objekt definiert werden (in der Tabelle unten beschrieben). Jeder Eintrag hat einen definierten Wert und kann eine Beschreibung haben. |
|---|---|---|
| Das im Werteattribut jedes Hinweiselements enthaltene JSON-Objekt kann die in der folgenden Tabelle beschriebenen Eigenschaften enthalten. | ||
| Typ | Zweck |
| Beschreibung | String | Eine kurze Beschreibung des Werts, der dem Benutzer angezeigt werden kann. Wenn keine Beschreibung vorhanden ist, kann diese weggelassen werden. Die letzte Zeile in der Beschreibung sollte mit einem Punkt (.) enden. |
|---|---|---|
SpringBoot命令行参数参考：https://www.yisu.com/article/191629.htm 启动Spring Boot项目时传递参数，有三种参数形式：
--foo --foo=bar --foo="bar then baz" --foo=bar,baz,biz
相当于 SpringBoot 基于 Java 命令行参数中的非选项参数自定义了选项参数的规则，具体可以看解析器 class SimpleCommandLineArgsParser {
public CommandLineArgs parse(String... args) {
CommandLineArgs commandLineArgs = new CommandLineArgs();
for (String arg : args) {
// --开头的选参数解析
if (arg.startsWith("--")) {
// 获得key=value或key值
String optionText = arg.substring(2, arg.length());
String optionName;
String optionValue = null;
// 如果是key=value格式则进行解析
if (optionText.contains("=")) {
optionName = optionText.substring(0, optionText.indexOf('='));
optionValue = optionText.substring(optionText.indexOf('=')+1, optionText.length());
} else {
// 如果是仅有key（--foo）则获取其值
optionName = optionText;
}
// 如果optionName为空或者optionValue不为空但optionName为空则抛出异常
if (optionName.isEmpty() || (optionValue != null && optionValue.isEmpty())) {
throw new IllegalArgumentException("Invalid argument syntax: " + arg);
}
// 封装入CommandLineArgs
commandLineArgs.addOptionArg(optionName, optionValue);
} else {
commandLineArgs.addNonOptionArg(arg);
}
}
return commandLineArgs;
}
}参数值的获取如果您需要访问传递给应用程序的参数 @Component
public class MyBean {
@Autowired
public MyBean(ApplicationArguments args) {
boolean debug = args.containsOption("debug");
List<String> files = args.getNonOptionArgs();
// if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
}
}
参数值的区别关于参数值区别，重点看选项参数和系统参数。通过上面的示例我们已经发现使用选项参数时，参数在命令中是位于 如果不按照该顺序进行执行，比如使用如下方式使用选项参数： java -jar --server.port=8081 xxx.jar 则会抛出如下异常： Unrecognized option: --server.port=8081 Error: Could not create the Java Virtual Machine. Error: A fatal exception has occurred. Program will exit. 如果将系统参数放在jar包后面，问题会更严重，会出现可以正常启动，但参数无法生效。这个错误是最坑的，所以一定谨记：通过-D传递系统参数时，务必放置在待执行的jar包之前。 扩展“外部化配置”属性源
SpingBoot怎么支持YAML配置文件解析？处理@PropertySource注解从ConfigurationClassParser#processPropertySource方法进 Spring中@PropertySource默认不支持YAML格式的解析，但是SpringBoot的配置文件却可以解析YAML，这说明SpringBoot中已经实现了YAML文件的解析，我们只需要复用即可，我们可以看该注解源码 /**
* Specify a custom {@link PropertySourceFactory}, if any.
* <p>By default, a default factory for standard resource files will be used.
* @since 4.3
* @see org.springframework.core.io.support.DefaultPropertySourceFactory
* @see org.springframework.core.io.support.ResourcePropertySource
*/
Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;PropertySourceFactory的默认实现是DefaultPropertySourceFactory public class DefaultPropertySourceFactory implements PropertySourceFactory {
@Override
public PropertySource<?> createPropertySource(@Nullable String name, EncodedResource resource) throws IOException {
return (name != null ? new ResourcePropertySource(name, resource) : new ResourcePropertySource(resource));
}
}ResourcePropertySource默认不支持YAML，所以我们可以通过实现PropertySourceFactory接口，然后用@PropertySource的factory属性来实现YAML的解析 public class YamlPropertySourceFactory implements PropertySourceFactory {
@Override
public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
yamlPropertiesFactoryBean.setResources(resource.getResource());
Properties yamlProperties = yamlPropertiesFactoryBean.getObject();
return new PropertiesPropertySource(name, yamlProperties);
}
}关于ApplicationEnvironmentPreparedEvent没有被执行的原因官方文档中有说到：有些事件实际上是在ApplicationContext被创建之前触发的，所以我们不能将这些事件的监听器注册为@Bean。 因为这个时候应用上下文还没有被创建，也就是说监听器也还没有被初始化，这个先后顺序不对，会导致这些事件的监听器不会被触发 但可以使用 如果您希望这些侦听器自动注册的话，可以通过新建一个 org.springframework.context.ApplicationListener=com.example.project.MyListener 应用程序事件应用程序运行时，应用程序事件按以下顺序发送：
Die obige Liste enthält nur SpringApplicationEvents, die an eine SpringApplication gebunden sind. Darüber hinaus werden nach ApplicationPreparedEvent und vor ApplicationStartedEvent auch die folgenden Ereignisse veröffentlicht:
|
Das obige ist der detaillierte Inhalt vonSo konfigurieren Sie die SpringBoot-Externalisierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!