Lorsque nous développons des applications basées sur Spring, nous plaçons généralement la configuration de la base de données dans le fichier Properties.
Résumé des points de connaissances impliqués dans l'analyse du code:
1.NAMESPACEHHANDLER PARE ESPACE DE NOMES CUSTOM dans le fichier de configuration XML
2.ContextNamespaceShandler Parser lié au contexte, définit ici l'analyseur spécifique pour l'analyse de la propriété-placement de la propriété
3.BeanDefinitionParser analyse l'interface de la définition du bean
4.BeanFactoryPostProcessor Après le chargement de la définition du bean, il peut être modifié.
5.PropertySourcesPlaceHolderConfigurer gère les espaces réservés dans la définition de haricots
Jetons un coup d'œil à l'utilisation spécifique en premier
Utilisation de la propriété
Configurer le fichier de propriétés dans le fichier XML
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <
De cette façon, le fichier /src/main/resources/foo.properties sera chargé par le printemps
Si vous souhaitez utiliser plusieurs fichiers de configuration, vous pouvez ajouter le champ de commande pour trier
Utiliser PropertySource pour annoter la configuration
Spring 3.1 a ajouté l'annotation @propertysource pour faciliter l'ajout de fichiers de propriété à l'environnement.
@ Configuration @ PropertySource ("ClassPath: foo.properties") Propriétés de classe publique avec WithJavaconfig {@Bean public static PropertySourcesPlaceHolderConfigurer PropertySourcesPlaceHolderConfigurer () {return new PropertySourcesPlaceHolderConfigurer (); }}Injection et utilisation des propriétés
1. Utilisez @Value Annotation pour obtenir en Java
@Value ("$ {jdbc.url}") String privé jdbcurl;Vous pouvez également ajouter une valeur par défaut
@Value ("$ {jdbc.url: adefaultUrl}") String privé jdbcurl;1. Obtenez-le dans le fichier de configuration XML de Spring
<bean id = "dataSource"> <propriété name = "url" value = "$ {jdbc.url}" /> </ bean>Analyse du code source
Chargement des informations de configuration des propriétés
Spring démarrera le travail d'initialisation du conteneur via AbstractApplicationContext # Refresh au démarrage, et pendant cette période, LoadBeAnDefinitions sera confiée pour analyser le fichier de configuration XML.
Protégé final void RefreshbeanFactory () lève BeanSexception {if (hasbeanfactory ()) {destrenBeans (); CloseBeanFactory (); } essayez {defaultListableBeAnfactory beanfactory = CreateBeAnfactory (); beanfactory.setSerializationId (getID ()); PersurizeBeAnfactory (BeanFactory); LoadBeAndefinitions (BeanFactory); synchronisé (this.beanfactoryMonitor) {this.beanfactory = beanfactory; }} catch (ioException ex) {lancez une nouvelle applicationContexTexception ("Erreur d'erreur d'erreur Source de définition de bean pour" + getDisplayName (), ex); }}LoadBeanDefinitions via la délégation couche par couche, trouvez la defautelBeanDefinitionDocumentReader # parsebeAndefinition pour analyser le haricot spécifique
Protégé void parsebeAndefinitions (élément root, beandefinitionParserDelegate Delegate) {if (delegate.isdefaultNamespace (root)) {nodelist nl = root.getchildNodes (); for (int i = 0; i <nl.getLength (); i ++) {node node = nl.item (i); if (nœud instanceof élément) {element ele = (élément) node; if (delegate.isdefaultNamespace (ele)) {parsedefaultElement (ele, délégué); } else {delegate.parsECustomElement (ele); }}}} else {delegate.parsECustomElement (root); }} Comme il ne s'agit pas d'une définition de classe standard, il configure BeanDefinitionParserDelegate pour analyser
Trouvez le processeur correspondant via NamespaceHandler pour trouver le contextNamespaceHandler, puis trouvez la propriété PlaceHolderBeAnDefinitionParser Analyser l'analyse par ID
@Override public void init () {// c'est l'analyseur que nous recherchons RegisterBeAnDefinitionParser ("Property-placeholder", New PropertyPlaceHolderBeAnDefinitionParser ()); RegisterBeAnDefinitionParser ("Property-Override", New PropertyOverideBeAnDefinitionParser ()); RegisterBeAnDefinitionParser ("Annotation-Config", New AnnotationConfigBeAnDeFiniitionParser ()); RegisterBeAndeFinitionParser ("Component-Scan", New ComponentsCanBeAnDeFinIitionParser ()); RegisterBeAnDefinitionParser ("Load-Time-Weaver", New LoadtimeWeaverBeAnDeFinIitionParser ()); RegisterBeAnDefinitionParser ("Spring-Configured", New SpringConfiguredBeAnDeFinIitionParser ()); RegisterBeAnDefinitionParser ("MBEAN-EXPORT", New MBeanExportBeAnDefinitionParser ()); RegisterBeAndefinitionParser ("MBean-Server", New MbeanServerBeAnDefinitionParser ()); } PropertyPlaceHolderBeAnDefinitionParser est au centre de cette série d'analyses de code.
Jetons un coup d'œil à sa classe de parents.
1.BeandefinitionParser
Utilisé par DefaultBeanDefinitionDocumentReader pour analyser les balises personnalisées
Seulement une API d'analyse que l'élément Parses est défini ici
Interface publique BeanDefinitionParser {BeanDefinition Parse (élément élément, ParserContext ParserContext);} 2.AbstraitBeAndefinitionParser
L'implémentation abstraite par défaut de l'interface BeanDefinitionParser. Le printemps est bon dans ce domaine. Il fournit ici de nombreuses API pratiques et utilise le modèle de conception de la méthode du modèle pour fournir des crochets d'implémentation personnalisés pour les sous-classes.
Jetons un coup d'œil à la logique de traitement spécifique lorsque l'analyse: Appelez le crochet Parseinternal Parse
3. AbstracSingleBeAnDefinitionParser
Analyser, définir la classe parent abstraite d'une seule haricot
Dans Parseinternal, Parse Parentnnnn, BEANCLASS, SOURCE; et encapsuler à l'aide de beandefinitionbuilder
4. AbstractPropertyloadingBeAndefinitionParser
Analyser les propriétés liées à la propriété, telles que l'emplacement, les propriétés-ref, le codage de fichiers, la commande, etc.
5.PropertyPlaceHolderBeAnDefinitionParser
Il n'y a pas beaucoup de choses à gérer ici, il suffit de configurer dans le mode d'insolvable et de mode System-Properties
Fichier de propriétés de chargement, instanciation du haricot
Ensuite, jetons un coup d'œil quand ce haricot est instancié. Il existe deux types d'instanciation des classes générales. L'un est instancié lorsque le système singleton est démarré; L'autre est instancié lorsque le non-Singleton (ou le chargement paresseux singleton) lorsque le getbean est instancié.
Le déclencheur ici est par le biais de BeanfcatoryPostprocessor.
BeanfactoryPostProcessor modifie la définition du bean avant l'instanciation des haricots. Par exemple, les espaces réservés dans la définition de haricots sont résolus ici, et les propriétés que nous utilisons actuellement sont également résolues ici.
Ceci est mis en œuvre via PostProcessorRegistrationDelegate # invokeBeanFactoryPostProcessors.
Scannez le preneur BeanfactoryPostprocessor dans le conteneur, trouvez la propriété PlacePlaceHolder Configurer ici et instanciez-la via le getbean du conteneur
VOID protégé invokeBeanFactoryPostProcessors (configurableListableBeanfactory beanfactory) {postprocessorRecgmentationdelegate.invokebeanfactoryPostProcessors (beanfactory, getbeanfactoryPostProcessors ()); }Une fois l'instanciation de PropertySourcesPlaceHolderConfigurer, il sera déclenché directement et chargé d'informations.
OrderComparator.Sort (priorityOrderEdPostProcessors); InvokeBeanFactoryPostProcessors (prioringOrdEdPostProcessors, Beanfactory);
Jetons un coup d'œil au système de succession de PropertySourcesPlaceHolder Concernurer
1.BeanfactoryPostprocessor
Définissez une interface pour modifier les propriétés de la définition du bean dans un conteneur. Sa classe d'implémentation est instanciée avant que les classes générales ne soient utilisées et que les propriétés d'autres classes sont modifiées.
Ceci est évidemment différent de BeanPostProcessor, qui modifie les instances de bean.
2.Propertiesloadersupport
Classe abstraite qui charge les fichiers de propriétés.
La logique de chargement spécifique ici consiste à confier des logements de propriétés # fillproperties à implémenter
3.PropertyResourceConfigurer
Le remplacement des espaces réservés dans la définition de haricots est mis en œuvre par cette classe abstraite.
Implémentez BeanfactoryPostProcessor # PostProcessBeanfactory, itérez sur la définition de la classe dans le conteneur et modifiez-le
Comment le modifier est implémenté en le remettant à une sous-classe via le Hook ProcessProperties
4.PlaceHolderconfigurersupport
Utilisez le modèle de conception des visiteurs pour mettre à jour les propriétés via BeanDefinitionVisitor et StringValueResolver
StringValueResolver est une interface qui convertit les données de type de chaîne. L'implémentation API qui met vraiment à jour les propriétés est en fait
PropertyPlaceHolderhelper # ParsestringValue
5.PropertySourcesPlaceHolder Concernure
Remplacer le processus d'analyse de définition de la définition de la définition de la définition de la définition de la définition API PROSTPROCESSORBEAN
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.