Explication détaillée des points de connaissance du framework Spring Boot

Résumé : 1. Fichier de configuration des propriétés de Spring Boot 1.1 La première forme du fichier de configuration des propriétés de Spring Boot utilise le fichier de configuration des propriétés, comme suit : La signification est de changez le port d'accès en 8081 et ajoutez un contextPath, ce qui peut être compris comme l'ajout d'une couche d'adresse supplémentaire à la barre d'adresse. server.port= ...

1. Fichier de configuration des propriétés Spring Boot

1.1 La première forme du fichier de configuration des propriétés de Spring Boot

En utilisant le fichier de configuration des propriétés, la signification des deux propriétés suivantes est de changer le port d'accès en 8081, et ajouté un contextPath, qui peut être compris comme l'ajout d'une couche supplémentaire d'adresses à la barre d'adresse.

server.port=8081
server.context-path=/joyou

Cliquez avec le bouton droit sur DemoApplication.java ——》Exécuter en tant que ——》Programme de démarrage de l'application Spring Boot

L'effet est le suivant. log, le port a été modifié en 8081

L'effet d'accès au navigateur est le suivant.

 

  Supplément :

Les fichiers de propriétés sont le moyen le plus courant de gérer les propriétés de configuration. La classe SpringApplication fournie par Spring Boot recherche et charge le fichier application.properties pour obtenir les valeurs des propriétés de configuration. La classe SpringApplication recherchera le fichier aux emplacements suivants :

1./config sous-répertoire du répertoire actuel

2.Répertoire actuel

3./config dans le package classpath

4.classpath

La séquence ci-dessus est également Indique la priorité des fichiers de propriétés contenus à cet emplacement. Les priorités sont classées de haut en bas.

Vous pouvez spécifier différents noms de fichiers de propriétés via l'attribut de configuration de la clé spring.config.name. Vous pouvez également ajouter le chemin de recherche de fichiers de propriétés supplémentaires via spring.config.location.

                                             >

                                                                  Le code est le suivant.

server:  port: 8082  context-path: /joyou

效果与1.1相同。

补充：

相对于属性文件来说，YAML 是一个更好的配置文件格式。当有前缀的情况下，使用.yml格式的配置文件更简单。

注意：使用.yml时，属性名的值和冒号中间必须有空格，如name: SpringBoot正确，SpringBoot就是错的。

YAML est très bien utilisé dans Ruby on Rails. YAML est un sur-ensemble de JSON et un format pratique pour définir des données de configuration hiérarchique. Ses règles de grammaire de base sont les suivantes :

• Sensible à la casse

• Utiliser l'indentation hiérarchique les relations

• n'autorisent pas l'utilisation de la touche Tab lors de l'indentation, n'autorisent que les espaces.

• Le nombre d'espaces en retrait n'est pas important, du moment que les éléments d'un même niveau sont alignés à gauche

• # représente un commentaire De ce caractère jusqu'à la fin de la ligne, il sera ignoré par l'analyseur.

1.3 Quelles clés dans application.properties sont configurables ?

La configuration détaillée et les instructions sont données dans la documentation du site officiel de SpringBoot. Dans l'annexe A. Propriétés communes de l'application : http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#common-application-properties

Statistiques incomplètes, cette version complète le fichier de propriétés de l’application contient 1 183 lignes. Parmi eux, il existe 950 clés d'attribut. Lorsque vous verrez une configuration aussi énorme, vous serez certainement choqué. Cependant, dans les projets réels, si nous suivons la convention de Spring Boot, nous n'avons généralement pas besoin de spécifier trop de configurations séparément.

<.> 1.4 La priorité de configuration

Spring Boot fournit un mécanisme de lecture prioritaire de la configuration pour nous aider à sortir de ce dilemme.

La séquence de priorités de configuration fournie par Spring Boot est relativement complexe. Par ordre de priorité de haut en bas, la liste spécifique (de haut en bas) est la suivante.

•        

    1. Paramètres de ligne de commande (priorité la plus élevée).

• 2. Paramètres système Java obtenus via System.getProperties().

• 3. Variables d'environnement du système d'exploitation.

• 4. Attributs JNDI obtenus à partir de java:comp/env.

• 5. Propriétés Random.* générées par RandomValuePropertySource.

• 6. Fichier de configuration Application-{profile}.properties ou application.yml (avec spring.profile) en dehors du package jar, via spring.config.location Spécification des paramètres

• 7.application-{profile}.properties ou application.yml (avec spring.profile) fichier de configuration à l'intérieur du package jar

• 8. Fichier de configuration Application.properties ou application.yml (sans spring.profile) en dehors du package jar

• 9. Le fichier de configuration application.properties ou application.yml (sans spring.profile) à l'intérieur du package jar

•                                                                                                                                                                                                                                                                  Appliquez la classe de configuration Java, y compris la classe Java annotée avec @Configuration, et les fichiers de propriétés déclarés via l'annotation @PropertySource.

• 11. Propriétés par défaut déclarées via SpringApplication.setDefaultProperties.

Si Spring Boot trouve une configuration dans un emplacement de priorité plus élevée, il ignorera la configuration de priorité inférieure. Ci-dessous, nous parlons brièvement de ces priorités. La priorité de configuration de Spring Boot semble compliquée, mais elle est en réalité très raisonnable. La priorité des paramètres de ligne de commande est définie sur la plus élevée car elle nous permet de modifier rapidement les valeurs des paramètres de configuration dans un environnement de test ou de production sans avoir besoin de reconditionner et de déployer l'application.

Par défaut, la classe SpringApplication convertira les paramètres de ligne de commande commençant par "--" en configurations qui peuvent être utilisé dans les paramètres de l'application , tels que "--name=Alex" définira la valeur du paramètre de configuration "name" sur "Alex".

Si vous n'avez pas besoin de cette fonction, vous pouvez passer SpringApplication.setAddCommandLineProperties(false)

Désactiver l'analyse des arguments de ligne de commande.

2. Propriétés personnalisées de Spring Boot

2.1、 第一个自定义属性的例子

在实际开发过程中，需要程序去配置文件中读取数据（如：URL，一些账号密码等），所以就需要我们来自定义属性，供程序读取。

首先在yml里自定一个属性，格式如下：

company: joyouemployee: 二十岁以后

在Java程序中取值,代码如下：

package com.example.demo;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloSpringBoot {	
	@Value("${company}")
	private String company;	
	@Value("${employee}")
	private String employee;	

	@RequestMapping(value="/hello" , method = RequestMethod.GET)
	public String HelloSpring(){		
			return company+"====="+employee;
	}
}

使用浏览器访问效果如下

2.2 Appeler d'autres attributs dans les attributs personnalisés

Configuration dans le fichier yml

company: joyouemployee: 二十岁以后   
All: "公司: ${company} , 员工: ${employee}"

在JAVA程序中注入All属性

package com.example.demo;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloSpringBoot {	
	@Value("${All}")	private String All;	
	
	@RequestMapping(value="/hello" , method = RequestMethod.GET)	public String HelloSpring(){		
			return All;
	}
}

效果如图所示：

2.3 对于多个属性如何一次调用

看了上面的例子后，会产生一个疑问，如果想一次调用10个、20个、50个属性值，难道我要在程序中注入50次值，使用50次注解吗？ 为了解决这个疑问，Spring Boot 是这么解决的！

首先一个女孩，有身高、体重、罩杯等等属性，我们可以这样来写！

Girl: 
   High: 160CM   Weight: 80KG   CupSize: 30A

然后写一个类，这个类中提供Girl的属性，及Setter，Geter方法，需要使用两个注解：

• @Component //如果没有这个注解，会报找不到Bean的错

• @ConfigurationProperties(prefix="Girl") //找到以Girl开头的属性

然后在java程序中注入Gril类

package com.example.demo;@RestControllerpublic class HelloSpringBoot {	@Autowired
	private Girl girl;	
	
	@RequestMapping(value="/hello" , method = RequestMethod.GET)
	public String HelloSpring(){		
			return girl.toString();
	}
}

                启动程序，刷新浏览器，效果如下：

3. Configuration des attributs multi-environnements

                                                                   Face à différents scénarios de production et de développement , cela peut être différent pour les valeurs de certains attributs. Dois-je modifier les valeurs d'attribut écrites dans l'environnement de développement pour les modifier une par une ? Maintenant que j’ai dit cela, cela n’est bien sûr pas nécessaire. Nous pouvons écrire deux ensembles de fichiers yml avec des exigences différentes pour les valeurs d'attribut dans les deux environnements pendant le développement, puis appeler les fichiers yml requis.

                                                                                                                                           , , avec avec avec avec avec avec avec avec avec avec avec ainsi donc avec donc avec tellement donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc donc opportunités, > J'ai juste besoin d'appeler différents fichiers dans application.yml La valeur dev est le nom de suffixe des différents fichiers yml dans mes environnements de développement et de production (.

Faites attention au nom des deux fichiers image ci-dessus

)

Le résultat correspondant au navigateur

La configuration correspondant au deuxième environnement

Résultats correspondants du navigateur

Ajoutez une image de la structure du répertoire du projet jusqu'à présent pour aider à comprendre

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!