Detaillierte Einführung in die Eigenschaftenkonfiguration

Der größte Teil der manuellen Konfiguration entfällt in SpringBoot, aber in einigen bestimmten Situationen müssen wir immer noch eine manuelle Konfiguration durchführen. SpringBoot stellt uns die Konfigurationsdatei application.properties zur Verfügung, die es uns ermöglicht, die Konfiguration an die Standardkonfigurationen anzupassen zur Anpassung an bestimmte Produktionssituationen, einschließlich einiger Konfigurationen von Drittanbietern. Fast alle Konfigurationen können in die Datei application.peroperties geschrieben werden, die automatisch von SpringBoot geladen wird, was uns die Mühe des manuellen Ladens erspart. Tatsächlich passen wir Konfigurationsdateien oft an, sodass SpringBoot sie nicht automatisch erkennt. Schauen wir uns diese Aspekte genauer an.

1. Konfigurationsdateiformat

SpringBoot kann zwei Formate von Konfigurationsdateien erkennen, nämlich yml-Dateien und Eigenschaftendateien. Wir können die Datei application.properties durch yml ersetzen Diese Dateien können von SpringBoot automatisch erkannt und geladen werden. Wenn es sich jedoch um eine benutzerdefinierte Konfigurationsdatei handelt, ist es am besten, die Eigenschaftenformatdatei zu verwenden, da SpringBoot noch nicht die Funktion zum manuellen Laden von YML-Formatdateien bietet ( Dies bezieht sich auf die Anmerkungsmethode).

Damit die Konfigurationsdatei application.properties automatisch von SpringBoot geladen wird, muss sie am angegebenen Speicherort abgelegt werden: Verzeichnis src/main/resource. Im Allgemeinen befinden sich auch benutzerdefinierte Konfigurationsdateien in diesem Verzeichnis.

2. Laden von Konfigurationsdateien

Laden bedeutet, die Datei in den Spring-Container zu laden, um sie zur sofortigen Verwendung zu laden.

Die Konfigurationsdatei application.properties wird automatisch geladen, wenn das SpringBoot-Projekt gestartet wird. Die entsprechenden internen Einstellungen überschreiben automatisch die entsprechenden Standardeinstellungen und alle Konfigurationselemente werden im Spring-Container gespeichert.

1-Öffentliche Konfigurationsdatei: application.properties

1 donghao.name=唯一浩哥2 donghao.sex=男3 donghao.age=80

Die angepasste Konfigurationsdatei xxx.properties wird von SpringBoot nicht automatisch geladen und muss manuell geladen werden Laden. Manuelles Laden bezieht sich hier im Allgemeinen auf das Laden durch Annotation. Dies betrifft heute einen unserer Schwerpunkte: die Annotation zum Laden benutzerdefinierter Eigenschaftendateien: @PropertySource("classpath:xxx.properties"). Diese Annotation wird speziell zum Laden der Eigenschaftendatei verwendet am angegebenen Speicherort stellt Spring noch keine Anmerkungen zum Laden der YML-Datei am angegebenen Speicherort bereit, weshalb die vorherige Anweisung getroffen wird.

2-Benutzerdefinierte Konfigurationsdatei: donghao.properties

1 donghao1.name=动画2 donghao1.sex=女3 donghao1.age=22

　　其实无论对于哪里的properties文件，当我们需要使用其中配置内容的时候，就在当前类的顶部加注该注解，将该配置文件加载到内存，这些配置文件一次加载即可多次使用。

3、配置项的使用

　　配置项的使用其实很简单，只要是加载到Spring容器中的配置项都可以直接使用@Value("${key}")的方式来引用，一般将其配置在字段顶部，表示将配置项的值赋值给该字段。

　　当然更多的情况是将这些配置项与一个JavaBean绑定起来使用，这样绑定一次，我们就可以随时使用。这里涉及到两种情况，一种是将application.properties中的配置与JavaBean绑定，一种是将自定义配置文件中的配置与Javabean绑定。

　　第一种：applicaiton.properties属性绑定JavaBean

　　这种情况相对简单（因为application.properties文件会被自动加载，也就是说配置项会被自动加载到内存，到Spring容器之中，省去了手动加载的配置），然后我们在要与属性绑定的JavaBean的类定义顶部加@Component注解和@ConfigurationProperties(prefix="key")注解，前者的目的是为了这个JavaBean可以被SpringBoot项目启动时候被扫描到并加载到Spring容器之中，重点是后者，这个注解一般不是单独使用的，他一般与后面要说的@EnableConfigurationProperties(JavaBean.class)配合使用，但是二者并非使用在同一位置，@ConfigurationProperties(prefix="key")注解加注在JavaBean类定义之上，按字面可以理解为属性配置注解，更直接点的说法就是属性绑定注解，官方解释是：如果想要绑定或者验证一些来源自.properties文件中的额外属性时，你可以在一个标注的@Configuration的类的注有@Bean注解的方法或者一个类之上加注这个注解。我们完全可以将其理解为绑定专用注解。它的作用就是将指定的前缀的配置项的值与JavaBean的字段绑定，这里要注意，为了绑定的成功，一般将字段的名称与配置项键的最后一个键名相同，这样整个键在去掉前缀的情况下就和字段名称一致，以此来进行绑定。

　　第二种：自定义配置的属性绑定JavaBean

　　这种情况与之前的基本相同，只是不能自动加载，需要手动加载，在JavaBean之上加上之前介绍的@PropertySource注解进行配置文件加载。还有一点就是将@Component改为@Configuration，为什么这么做呢？

　　@Configuration注解的底层就是@Component，但是二者意义不同，@Configuration注解侧重配置之意，@Component侧重组件之意，当然配置也是项目组件之一，在这里我们要将配置文件属性与JavaBean绑定，当然更侧重配置之意。

　　将配置与JavaBean绑定之后，我们就可以通过JavaBean来获取配置的内容，而且JavaBean已经被@Component注解或者@Configuration注解加载到Spring容器，我们可以使用自动注入的方式在其他类中随便使用。

　　这里要注意一点：当我们在某个类中要使用这个JavaBean时，需要在这个类中指定这个JavaBean的类型，这个指定也要使用注解来制定，正是之前介绍的@EnableConfigurationProperties注解，这个注解与@ConfigurationProperties注解配套使用。官方给出的解释：这个注解是对@ConfigurationProperties的有效支持。标注有@ConfigurationProperties注解的Beans可以被使用标准的方式注册（使用@Bean注解），或者，为了方便起见，直接用使用@EnableConfigurationProperties指定注册。意思是这个注解提供了一种方便直接的注册Bean的方式。

3-绑定JavaBean：Donghao.java

 1 package com.donghao.model; 2  3 import org.springframework.boot.context.properties.ConfigurationProperties; 4 import org.springframework.context.annotation.Configuration; 5 import org.springframework.context.annotation.PropertySource; 6  7 @Configuration 8 @PropertySource("classpath:donghao.properties") 9 @ConfigurationProperties(prefix="donghao1")10 public class Donghao {11     private String name;12     private String sex;13     private String age;14     public String getName() {15         return name;16     }17     public void setName(String name) {18         this.name = name;19     }20     public String getSex() {21         return sex;22     }23     public void setSex(String sex) {24         this.sex = sex;25     }26     public String getAge() {27         return age;28     }29     public void setAge(String age) {30         this.age = age;31     }32 }

4-定义控制器：DonghaoController

 1 package com.donghao.controller; 2  3 import org.springframework.beans.factory.annotation.Autowired; 4 import org.springframework.beans.factory.annotation.Value; 5 import org.springframework.boot.context.properties.EnableConfigurationProperties; 6 import org.springframework.web.bind.annotation.RequestMapping; 7 import org.springframework.web.bind.annotation.RestController; 8  9 import com.donghao.model.Donghao;10 11 @RestController12 @RequestMapping("/donghao")13 @EnableConfigurationProperties(Donghao.class)14 public class DonghaoController {15     16     @Autowired17     Donghao donghao;18     19     @Value("${donghao.name}")20     private String name;21     22     @Value("${donghao.sex}")23     private String sex;24     25     @Value("${donghao.age}")26     private String age;27 28     29     @RequestMapping("/hello")30     public String hello(){31         return "我的名字叫"+name+",我是"+sex+"生,今年"+age+"岁了!";32     }33     34     @RequestMapping("/ss")35     public String ss(){36         return donghao.getName()+donghao.getSex()+donghao.getAge();37     }38 }

5-定义启动入口类：DonghaoApplication.java

 1 package com.donghao; 2  3 import org.springframework.boot.SpringApplication; 4 import org.springframework.boot.autoconfigure.SpringBootApplication; 5  6 @SpringBootApplication 7 public class DonghaoApplication { 8  9     public static void main(String[] args) {10         11         SpringApplication.run(DonghaoApplication.class, args);12         13     }14 15 }

Nach dem Starten des Programms greift der Browser auf http://localhost:8080/donghao/hello zu und das Ergebnis ist:

Der Browser greift auf Folgendes zu: http: //localhost :8080/donghao/ss

Ich möchte hier betonen, dass Laden und Verwendung nicht miteinander zusammenhängen. Obwohl der Zweck des Ladens die Verwendung ist, besteht keine Beziehung Es besteht kein enger Zusammenhang zwischen dem Laden und dem Gebrauch, aber es ist nicht praktikabel. Diese Anmerkungen stehen in keinem engen Zusammenhang. Sie haben jeweils ihre eigenen Unterschiede. Wenn Sie nur eine @PropertySource-Anmerkung laden, müssen Sie sich keine Gedanken über die Verwendungsanmerkungen machen Wenn Sie es direkt verwenden, können Sie den Wert der in den Spring-Container geladenen Eigenschaftskonfiguration direkt zuweisen Verwenden Sie die Bindung von JavaBean.

Beachten Sie außerdem, dass Sie niemals unterschiedliche Werte derselben Konfigurationselemente in der öffentlichen Konfigurationsdatei application.properties und der benutzerdefinierten Konfigurationsdatei xxx.properties konfigurieren sollten, da die öffentliche Konfigurationsdatei die höchste Priorität hat. Wird den Inhalt in der benutzerdefinierten Konfigurationsdatei überschreiben. Sie können verstehen, dass beim Start eine bestimmte Konfiguration in der öffentlichen Konfigurationsdatei und dann ein Konfigurationselement mit demselben Namen in eine andere benutzerdefinierte Konfigurationsdatei geladen wird Zwei haben unterschiedliche Werte, aber das System prüft die Priorität der beiden. Wer höher ist, bleibt, wer niedriger ist, geht und schließlich ist der Wert in der benutzerdefinierten Konfigurationsdatei ungültig.

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die Eigenschaftenkonfiguration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!