Introduction détaillée à la configuration des propriétés

SpringBoot élimine la plupart des configurations manuelles, mais pour certaines situations spécifiques, nous devons toujours effectuer une configuration manuelle. SpringBoot nous fournit le fichier de configuration application.properties, nous permettant de personnaliser la configuration par défaut. Les configurations sont modifiées pour s'adapter à une production spécifique. situations, y compris certaines configurations tierces. Presque toutes les configurations peuvent être écrites dans le fichier application.peroperties, qui sera automatiquement chargé par SpringBoot, nous évitant ainsi les problèmes de chargement manuel. Mais en fait, nous personnalisons souvent les fichiers de configuration, ce qui nous oblige à les charger manuellement. SpringBoot ne reconnaîtra pas automatiquement ces fichiers. Examinons ces aspects de plus près.

1. Format du fichier de configuration

SpringBoot peut reconnaître deux formats de fichiers de configuration, à savoir les fichiers yml et les fichiers de propriétés. Nous pouvons remplacer le fichier application.properties par application yml. de ces fichiers peuvent être automatiquement reconnus et chargés par SpringBoot, mais s'il s'agit d'un fichier de configuration personnalisé, il est préférable d'utiliser le fichier au format de propriétés, car SpringBoot ne fournit pas encore la fonction de chargement manuel des fichiers au format yml (cela fait référence au méthode d'annotation).

Pour être automatiquement chargé par SpringBoot, le fichier de configuration application.properties doit être placé à l'emplacement spécifié : répertoire src/main/resource Généralement, les fichiers de configuration personnalisés se trouvent également dans ce répertoire.

2. Chargement des fichiers de configuration

Le chargement signifie lire le fichier dans le conteneur Spring Pour être plus précis, cela signifie charger chaque élément de configuration dans le conteneur de contexte Spring pour une utilisation prête.

Le fichier de configuration application.properties est automatiquement chargé au démarrage du projet SpringBoot. Ses paramètres internes associés écraseront automatiquement les paramètres correspondants par défaut de SpringBoot et tous les éléments de configuration seront enregistrés dans le conteneur Spring.

1-Fichier de configuration public : application.properties

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

Le fichier de configuration xxx.properties personnalisé ne sera pas automatiquement chargé par SpringBoot et doit être chargé manuellement Chargement. Le chargement manuel fait généralement référence ici au chargement par annotation. Cela implique l'un de nos objectifs aujourd'hui : l'annotation pour le chargement des fichiers de propriétés personnalisés : @PropertySource("classpath:xxx.properties"). à l'emplacement spécifié, Spring n'a pas encore fourni d'annotations pour charger le fichier yml à l'emplacement spécifié, donc la déclaration précédente est faite.

2-Fichier de configuration personnalisé : 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 }

Après avoir démarré le programme, le navigateur accède à : http://localhost:8080/donghao/hello, et le résultat est :

Le navigateur accède à : http : //localhost :8080/donghao/ss

Je tiens à souligner ici que le chargement et l'utilisation ne sont pas liés. Bien que le but du chargement soit d'utiliser, il n'y a aucune relation. entre le chargement et l'utilisation. Ce n'est pas fortement lié. Nous pouvons le charger mais ce n'est pas pratique, nous devons donc analyser le processus de chargement et le processus d'utilisation séparément. Ils correspondent à des annotations différentes. Ils ont chacun leurs propres différences. Chacun a son propre objectif Si vous chargez simplement un fichier de configuration personnalisé, une seule annotation @PropertySource suffit. Vous n'avez pas à vous soucier des annotations d'utilisation. peut choisir une variété de méthodes d'utilisation.Si vous l'utilisez directement, nous utilisons l'annotation @Value pour l'affectation directe. Cette annotation peut directement attribuer la valeur de la configuration de propriété chargée dans le conteneur Spring au champ spécifié. utilisez la méthode de liaison de JavaBean.

Une autre chose à noter est de ne jamais configurer des valeurs différentes du même élément de configuration dans le fichier de configuration public application.properties et le fichier de configuration personnalisé xxx.properties, car le fichier de configuration public a la priorité la plus élevée. Écrasera le contenu du fichier de configuration personnalisé. Vous pouvez comprendre qu'une configuration dans le fichier de configuration public est chargée dans le conteneur Spring au démarrage, puis qu'un élément de configuration portant le même nom est chargé dans un autre fichier de configuration personnalisé, les deux. ont des valeurs différentes, mais le système vérifiera la priorité des deux, celui qui est le plus haut restera, celui qui est le plus bas partira, et enfin la valeur dans le fichier de configuration personnalisé n'est pas valide.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!