La relation entre le haricot et le conteneur de ressort
Les informations de configuration des haricots définissent la mise en œuvre et les dépendances des haricots. Spring Container établit le registre de définition des haricots dans le conteneur en fonction de diverses formes d'informations de configuration de haricots, puis charge et instancie les haricots en fonction du registre, et établit des dépendances entre les haricots et les haricots. Enfin, ces haricots prêts sont placés dans le pool de cache de haricots pour que les applications externes puissent appeler.
Cet article vous présentera en détail l'utilisation de méthodes de codage pour configurer dynamiquement les haricots au printemps. Nous les partagerons pour votre référence et votre apprentissage. Je ne dirai pas beaucoup ci-dessous, jetons un coup d'œil à l'introduction détaillée ensemble.
1 DefaultListableBeanfactory
DefaultListableBeAnFactory implémente l'interface ConfigurableLlistableBeAnfactory, qui peut injecter dynamiquement des haricots via cette classe. Afin de garantir que le haricot injecté peut également être amélioré par AOP, nous devons implémenter l'interface postprocesseur d'usine du bean BeanfactoryPostProcessor.
Haricots qui nécessitent une injection dynamique:
classe publique BookService {bookdao bookdao; public void setbookdao (bookdao bookdao) {this.bookdao = bookdao; } public bookdao getBookDao () {return bookdao; }}Implémentation de l'interface post-processeur d'usine du Bean:
@ComponentPublic Class BookServiceFactoryBean implémente beanfactoryPostProcessor {public void PostProcessBeanFactory (configurableListableBeanfactory beanfactory) lance BeanSexception {defaitListableBeanFactory Factory = (defaultListableBeanFactory) BeanFactory; // Définition de bean BEADDEFINITIONBUILDER BUILDER = BeanDefinitionBuilder.GenericBeAndefinition (BookService.class); // Définit la propriété Builder.AddPropertyReference ("bookdao", "bookdao"); // Enregistrer la définition de haricot Factory.RegisterBeAnDefinition ("BookService1", builder.getrawbeAnDefinition ()); // Enregistrer le bean instance factory.Registersingleton ("BookService2", new net.deniro.spring4.damic.bookservice ()); }}Ici, on suppose que BookDao a été injecté dans le conteneur (XML ou méthode d'annotation).
Ici, nous pouvons enregistrer la définition d'un haricot ou enregistrer directement l'instance d'un haricot.
Configuration:
<Context: Component-Scan Base-Package = "Net.DENIRO.Spring4.Damic" />
Tests unitaires:
BookService BookService1 = (BookService) context.getBean ("BookService1"); assertnotnull (bookservice1); assertnotnull (bookservice1.getBookDao ()); bookservice bookservice2 = (bookservice) context.getBean ("bookservice2"); assernotnull (bookservice2);2 balises personnalisées
Pour mieux encapsuler les composants et améliorer leur facilité d'utilisation, nous définissons les composants comme des étiquettes.
Les étapes pour personnaliser la balise sont:
Créer BookService.xsd sous le dossier de schéma dans Resources
<? xml version = "1.0" Encoding = "utf-8"?> <xsd: schema xmlns = "http://www.deniro.net/schema/service" xmlns: xsd = "http://www.w3.org/2001/xmlschema" xmlns: beans = "http://www.springframework.org/schema/beans" TargetNamespace = "http://www.deniro.net/schema/service" elementFormDefault = "Qualified" attributeFordefault = "Unqualified"> <! - Importation d'importation Beans Namespace -> <xsd: Unqualifiée "> <! namespace = "http://www.springframework.org/schema/beans" /> <! - Define Book-Service Tag -> <xsd: element name = "book-service"> <xsd: complexType> <xsd: complexcent> <xsd: extension Base = "Beans: IdentifiedType"> <! <xsd: attribut name = "dao" type = "xsd: string" use = "required" /> </ xsd: extension> </ xsd: complexContent> </xsd: complexType> </xsd: élément> </xsd: schema>
Définissez ensuite l'analyseur de balise de service:
classe publique BookServiceDeFinitionPaSer implémente BeanDefinitionParser {Public BeanDefinition Parse (élément élément, ParserContext ParserContext) {// Créer la définition BeanBeandeFinitionBuilder Builder = BeanDefinitionBuilder. // Inject Custom Tag Attribute String Dao = element.getAttribute ("dao"); builder.adddpropertyReference ("bookdao", dao); // Enregistrer Bean Define ParserContext.RegisterBeanComponent (new BeanComponentDefinition (Builder .getRaWBeAnDefinition (), "BookService")); retourner null; }}Ensuite, enregistrez l'analyseur que vous venez de définir dans l'espace de noms:
classe publique BookServiceNamespaceHandler étend des noms d'espace-handlersupport {public void init () {registreBeAnDeFinIitionParser ("Book-Service", New BookServiceDeFinitionParser ()); }}Créez ensuite le dossier Meta-Inf dans Resources et créez Spring.schemas et Spring.Handlers, qui sont utilisés pour configurer le chemin du fichier de structure de document de la balise personnalisée et l'analyseur qui analyse l'espace de noms personnalisé.
Chemin de fichier
Spring.Handlers:
http /: //www.deniro.net/schema/service=net.deniro.spring4
Spring.schemas:
http /: //www.deniro.net/schema/service.xsd=schema/bookservice.xsd
Remarque: Le fichier XSD doit être placé dans le répertoire des ressources descendants.
Citant des balises personnalisées:
<? 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: me = "http://www.deniro.net/schema/service" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans http://www.deniro.net/schema/service http://www.deniro.net/schema/service.xsd "> <bean id =" bookdao "/> <me: book-service dao =" bookdao "/> </ beans>
Ici, nous avons référencé la balise personnalisée à la tête et l'avons nommée "moi", puis nous pouvons l'utiliser o (∩_∩) o ~
Résumer
Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.