1. Présentation de la configuration du ressort
1.1. Aperçu
Le conteneur de ressort lit les informations de configuration du bean à partir de la configuration XML, de l'annotation Java et de l'annotation de ressort pour former un registre de définition de bean;
Définissez le registre pour instancier le haricot selon le haricot;
Mettez les instances de haricot dans la piscine de cache de haricots;
L'application utilise des haricots.
1.2. Configuration basée sur XML
(1) Aperçu du fichier XML
xmlns -----------------------------------------------------------------------------------------------------------------------
XMLNS: XSI ------------ Espace de noms standard, utilisé pour spécifier le fichier de schéma de l'espace de noms personnalisé
xmlns: xxx = "aaaaa" ------------ Espace de noms personnalisé, xxx est un alias, et la valeur suivante aaaa est le nom complet
XSI: ScheMalocation -------- Spécifiez un fichier de schéma spécifique pour chaque espace de noms, format: l'adresse de fichier de nom complet de l'espace de noms. . . Séparer avec les espaces
2. Configuration de base du bean
2.1. Nommer des haricots
(1) L'ID et le nom peuvent spécifier plusieurs noms, et les noms sont séparés par des virgules, des demi-colons ou des espaces.
<Beanname = "# Car, 123, $ car" class = "xxxxxxxxx">
Les utilisateurs peuvent utiliser GetBean ("# car"), getbean ("123"), getbean ("$ car") pour getbean.
(2) Si aucun ID et les attributs de nom ne sont spécifiés, Spring utilisera automatiquement le nom entièrement qualifié de la classe comme nom du haricot
(3) S'il y a plusieurs haricots anonymes, c'est-à-dire qu'il n'y a pas <Bean /> avec ID et nom spécifié, en supposant que le nom entièrement qualifié de la classe est xxx.
Ensuite, obtenez le premier bean à l'aide de getBean ("xxx"), obtenez le deuxième bean à l'aide de getBean ("xxx # 1"), obtenez le troisième bean en utilisant GetBean ("xxx # 2").
3. Injection de dépendance
3.1. Injection d'attribut
(1) L'injection d'attribut nécessite que le bean fournisse un constructeur par défaut et fournit une méthode de setter pour les attributs qui doivent être injectés. Spring appelle le constructeur par défaut pour instancier l'objet bean, puis appelle la méthode du secteur pour injecter la valeur de propriété via la réflexion.
(2) Spring ne vérifiera que s'il existe une méthode de setter correspondante dans le haricot, et aucune exigence ne sera faite pour savoir s'il existe une variable d'attribut correspondante dans le haricot.
(3) Spécifications spéciales de Javabean pour la dénomination des attributs: les 2 premières lettres d'une variable sont soit toutes les majuscules ou toutes les minuscules.
3.2. Injection de constructeur
(1) L'ordre de configuration des paramètres du constructeur n'affectera pas les résultats de configuration. Le fichier de configuration de Spring adopte une stratégie qui n'est pas liée à l'ordre des étiquettes des éléments. Cette stratégie peut assurer la certitude des informations de configuration dans une certaine mesure.
(2) correspondre aux paramètres par index
Si le type de paramètre d'entrée du constructeur est le même, vous devez spécifier l'index séquentiel des paramètres, sinon la relation correspondante ne peut pas être déterminée. comme:
<constructor-argindex = "0" value = "xxxxxx"> <constructor-argindex = "1" value = "xxxxxx">
L'index commence à 0.
(3) Problème de dépendance circulaire
Si la configuration du constructeur de 2 haricots dépend de l'autre partie, un problème de blocage de thread se produira.
La solution consiste à modifier l'injection du constructeur pour attribuer l'injection.
3.3. Injection de méthode d'usine
(1) Méthode d'usine non statique
Étant donné que la méthode d'usine n'est pas statique, vous devez d'abord créer un bean d'instance de la classe d'usine et utiliser l'usine de l'usine pour le référencer
<anEdId = "carfactory" class = "Factory Class" /> <Eanid = "Car5" factory Bean = "Carfactory" Factory-Method = "CreateCar" />
(2) Méthode d'usine statique
<Beanid = "Car5" class = "Factory Class" Factory-Method = "CreateCar" />
3.4. Explication détaillée des paramètres d'injection
(1) 5 caractères spéciaux en XML
| Symboles spéciaux | Séquence d'évasion | Symboles spéciaux | Séquence d'évasion |
| < | < | "" | |
| > | > | ' | ' |
| & | & |
(2) <! [Cdata []]>
Le but de <! [Cdata []]> est de laisser l'analyseur XML traiter la chaîne dans la balise comme un texte normal.
(3) Injecter la valeur nul à l'aide de la balise <null />
(4) Attributs en cascade
<anceid = "parent" class = "xxxxxxxx"> <propriétéName = "child.xxx" value = "Valeur de propriété de l'objet de dépendance" /> </Ebris>
Avant Spring3.0, l'enfant de l'objet de dépendance doit d'abord être instancié, sinon une exception sera lancée. Après Spring3.0, il n'est pas nécessaire d'afficher l'instanciation. Le conteneur à ressort instanciera automatiquement l'objet de dépendance.
(5) Fusion de la collection
<setMerge = "true" />
Couramment utilisé dans les sous-classes pour fusionner les éléments de collecte de la classe parentale
(6) Configurer des haricots de type collection via l'espace de noms Util
Si vous souhaitez configurer un bean de type collection au lieu d'une propriété de type collection, vous pouvez le configurer via l'espace de noms Util.
3.5. Assemblage automatique
(1) L'élément <Bean /> fournit un attribut qui spécifie le type de automatique
3.6. Injection de méthode
Si nous injectons les prototypes de haricots dans des haricots en mode simple et espérons retourner un nouveau haricot à chaque fois que nous l'appelons, il ne sera pas possible d'utiliser des méthodes d'injection traditionnelles car l'action des haricots en mode singleton injectant les haricots associés ne se produit qu'une seule fois.
(1) Une solution facultative consiste à permettre au bean hôte d'implémenter l'interface BeanfactoryAware, afin que le bean hôte puisse accéder aux références du conteneur, afin que la méthode GET puisse être modifiée et le conteneur
Factory.getBean ("Bean Depenated"), vous pouvez obtenir le dernier bean à chaque fois.
(2) La méthode ci-dessus couple notre code et notre ressort, ce qui est la pire façon de faire, et nous pouvons se découpler par l'injection de méthode.
Nous avons seulement besoin de définir une interface et de définir une méthode abstraite pour obtenir des haricots dépendants dans l'interface. La configuration du ressort est la suivante:
<ananid = "car" class = "Depenated Bean" /> <anEdId = "host" class = "Interface Bean"> <Lookup-MethodName = "getCar" bean = "Car" /> </Ean>
La balise de l'élément de méthode de recherche fournit une implémentation dynamique pour getCar () des beans d'interface. La mise en œuvre de l'injection de méthode repose principalement sur la technologie dynamique ByteCode du package CGLIB.
3.7. Remplacement de la méthode
Utilisez Bean2 pour remplacer la méthode GetCar de Bean1, à condition que Bean2 ait implémenter l'interface MethodReplacer, et la configuration est la suivante:
<anEdId = "bean1" class = "aaaaaaaaaa"> <remplacé-méthodname = "getCar" remplacer = "bean2" /> </ bean> <anEd = "bean2" class = "bbbbbbbbb" />
4. La relation entre <an Bean>
4.1. Héritage
La configuration du haricot parent peut être héritée par les sous-classes pour éviter les définitions répétées. La configuration est la suivante:
<anEdId = "parent bean" class = "aaaaaa" abstract = "true" /> <anonid = "child bean" class = "bbbbbb">
Les sous-classes peuvent remplacer la configuration de la classe parent. Si le Abstract = "True" de la classe Parent n'est pas spécifié, le haricot parent sera instancié.
4.2. Dépendance
Certains haricots sont instanciers dépendre d'autres haricots et d'autres haricots doivent être instanciés avant de pouvoir instancier le haricot hôte. Spring fournit l'attribut Detend-on et spécifie que le bean de dépendance est instancié en premier, tel que:
<beanid = "host" class = "aaaaaa" defend-on = "b1" /> <beanid = "b1" class = "bbbbbbbb" />
S'il y a plusieurs haricots de prédépendance, vous pouvez créer le nom du haricot par des virgules, des espaces ou des demi-colons.
4.3. Gamme de haricots
(1) Le récipient à ressort instanciera tous les haricots au début. Si vous ne voulez pas instancier à l'avance, la propriété Lazy-Init = "True" de <Bean /> peut contrôler l'instanciation retardée, mais si le haricot est référencé par d'autres haricots qui doivent être instanciés à l'avance, Spring ignorera également le réglage d'instanciation retardé.
(2) portée liée à l'application Web
Si l'utilisateur utilise la requête, la session et la portée des GlobalSession, la configuration supplémentaire doit être effectuée dans le conteneur Web d'abord:
Dans les versions inférieures des conteneurs Web (avant le servlet 2.3), vous pouvez utiliser la configuration du filtre de demande HTTP:
<filter> <filter-name> requestContextFilter </ Filter-Name> <Filter-Class> org.springframework.web.filter.requestContextFilter </ Filter-Class> </ Filter> <filter-Mapping> <filter-name> requestContex
Dans les versions supérieures des conteneurs Web, vous pouvez utiliser l'auditeur de la demande HTTP à configurer:
<Douger> <écouteur-classe> org.springframework.web.context.request.requestContextListener </ auteur-classe> </diner>
(3) Problème de dépendance à la portée
Lorsque vous injectez des haricots en ligne dans le singleton ou les grains de prototype, utilisez AOP, par exemple:
<bean id = "web1" scope = "request"> <aop: scoped-proxy /> </-bean> <bean id = "singleton1"> <propriété name = "z1" ref = "web1" /> </ank>
4.4. Usine
D'une manière générale, Spring utilise l'attribut de classe de <Bean /> pour spécifier le bean d'instanciation de classe d'implémentation via le mécanisme de réflexion. Mais dans certains cas, le processus d'instanciation d'un haricot est plus compliqué. Si, de la manière traditionnelle, une grande quantité d'informations de configuration est requise dans le <an Bean>. La flexibilité de la méthode de configuration est limitée et une solution simple peut être obtenue en utilisant des méthodes de codage.
Spring fournit une interface de classe d'usine org.springframework.beans.factory.factorybean, et les utilisateurs peuvent personnaliser la logique des haricots instanciels en implémentant cette interface.
Lorsque la classe d'implémentation configurée par l'attribut de classe de <Bean /> est FactoryBean et sa sous-classe, le retour de la méthode FactoryBean () ne renvoie pas le FactoryBean et sa sous-classe lui-même, mais l'objet renvoyé par la méthode FactoryBean getObject ().
Si vous voulez obtenir l'objet de FactoryBean et sa sous-classe lui-même, préfixez explicitement le nom de beanname avec un "&" préfixe, comme getbean ("& car5") lorsque la méthode getbean (beanname).
5. Configuration basée sur l'annotation
5.1. Type d'annotation
@Component ----- Annotation native
Annotations dérivées:
@Repository: annoter dao
@Service: service d'étiquette
@Controller: Contrôleur d'annotation
5.2. Utilisez des informations de configuration d'annotation pour démarrer le conteneur à ressort
(1) Après le printemps 2.5, l'espace de noms de contexte a été introduit, qui fournit l'application d'annotations pour définir les haricots en scannant le package de classe:
<Context: Component-Scan Base-Package = "xxxxxxxxxx" Resource-Pattern = "xxxx / *. Class">
L'attribut Resource-Pattern est utilisé pour spécifier des classes sous des packages spécifiques qui doivent être analysés dans le package de base
(2) Il y a des sous-étiquettes de filtre plus puissantes
<context: composant-scan basage-package = "xxxxxxxxxx"> <contexte: include-filter type = "xxxx" expression = "xxxxxxxxxxxxxxxx" /> <contexte: exclure-filter type = "xxxx" expression = "xxxxxxxxxxx"
De tous types, la capacité de filtrage de l'aspectj est la plus puissante.
5.3. Assemblage automatique des haricots
(1) @Autowired
@Autowired correspond par type par défaut. S'il n'y a pas de haricot assorti dans le conteneur, une exception sera lancée lorsque le conteneur à ressort commencera. Vous pouvez utiliser @Autowired (obligatoire = false) pour l'annotation, et aucune exception ne sera lancée.
Utilisez @Autowired pour annoter directement les paramètres de la méthode. Si une méthode a plusieurs paramètres, par défaut, Spring sélectionne automatiquement les Beans correspondant au type de paramètre pour l'injection.
En utilisant l'annotation @Autowired des variables de collecte, vous pouvez injecter tous les haricots qui correspondent au type d'élément de la collection, qui est très puissant.
En utilisant la propriété d'assembleur @Autowired, il ne peut y avoir de méthode de setter.
(2) @qualifiler
S'il y a plus d'un haricot correspondant dans le conteneur, le nom du haricot peut être qualifié par l'annotation @qualifiler.
(3) Support pour le marquage et l'annotation
Spring prend également en charge @Resource définie par JSR-250 et @Inject Annotations définies par JSR-330
@Resource exige que un bean d'attribut d'un bean soit fourni. Si l'attribut est vide, le nom de la variable ou le nom de la méthode sera automatiquement utilisé comme nom du bean.
(4) Points clés:
Si vous utilisez uniquement @Autowired, nous devons toujours définir explicitement le nœud <bean /> dans le XML. Le conteneur à ressort désactive l'assemblage d'annotation par défaut. La façon de l'activer est de configurer l'élément <Context: Annotation-Config /> dans le XML.
Mais le printemps fournit également une autre astuce. En utilisant l'élément <context: composant-scan />, le conteneur de ressort détectera automatiquement le bean sans définir explicitement le nœud <bean />.
Spring annote la classe d'annotation via @Component, @Repository, @Service et @Controller, de sorte que <Context: Component-Scan /> sait quelles classes doivent être enregistrées comme Springbean.
Si vous utilisez un package de pot tiers et que vous souhaitez injecter automatiquement des classes dans le package de jar tiers, même si le package de jar tiers ne les annott pas avec des annotations, l'élément filtrant <context: incluant-filter> peut remplacer la stratégie de numérisation des composants d'annotation, de sorte que <context: Component-Scan /> registre automatiquement des classes qui répondent aux expressions d'expression de l'expression.
5.4. La portée de l'action et la méthode du processus de vie de Bean
(1) @Scope ("xxxx")
La plage par défaut de haricots configurés par annotation est Singleton.
Spring fournit une annotation @scope. En ce qui concerne la classe, les paramètres d'annotation sont les mêmes que la valeur de l'attribut de portée dans XML.
(2) Comparaison des méthodes de processus de vie
| <fEAN> | annotation |
| init-méthode | @PostConstruct |
| Méthode destory | @Predestroy |
Différence: les annotations peuvent définir plusieurs méthodes dans une classe, et les méthodes sont exécutées dans l'ordre
6. Configuration basée sur Java
6.1. Utilisez des classes Java pour fournir des informations de définition de bean
(1) Le POJO ordinaire peut fournir des informations de définition de bean pour les conteneurs de ressort tant que l'annotation @configuration est marquée. Chaque méthode marquée de @Bean équivaut à fournir une information de définition de bean.
(2) @Bean
Le type de haricot est déterminé par le type de valeur de retour de la méthode annotée par @Bean
Le nom par défaut du bean est le même que le nom de la méthode, et il peut également être explicitement spécifié par @bean (name = "xxx").
Vous pouvez utiliser @scope chez @bean pour indiquer la portée d'utilisation du haricot
(3) @configuration
Étant donné que la classe d'annotation @configuration elle-même a été marquée de l'annotation @component, toute classe marquée avec @configurstion peut être automatiquement assemblée en d'autres classes à l'aide de @Autowired.
6.2. Démarrez le conteneur à ressort à l'aide d'informations de configuration basées sur la classe Java
(1) Spring fournit une classe AnnotationConfigApplicationContect, qui peut démarrer directement le conteneur de printemps via l'annotation @configuration annotée de classe.
(2) Lorsqu'il existe plusieurs classes de configuration
Vous pouvez vous inscrire un par un via la méthode du registre de AnnotationConfigApplicationContect, puis appelez la méthode d'actualisation pour actualiser le conteneur pour appliquer ces classes de configuration enregistrées.
Vous pouvez également utiliser l'annotation @Import (xxx.class) pour introduire toutes les autres classes de configuration dans une classe de configuration, afin que vous n'ayez besoin que d'enregistrer une seule classe de configuration.
(3) Reportez-vous à la configuration de @configuration via la classe de configuration XML
<Context: Component-ScanBase-Package = "..." Ressource-Pattern = "Configuration Class Name">
(4) Référence des informations de configuration XML dans la classe de configuration
Utilisez @ImportResource ("ClassPath: ............") à @configuration pour importer le fichier de configuration XML
6.3. Comparaison de 3 méthodes de configuration
| Xml | annotation | Classe Java |
| La classe d'implémentation de Bean est le développement actuel de projet | Contrôlez la logique globale de l'initialisation des haricots via le code, adapté aux scénarios où l'instanciation des haricots est plus complexe |
Résumer
Ce qui précède est toute l'explication détaillée des haricots d'assemblage du ressort dans les conteneurs IOC. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:
Une explication détaillée des trois méthodes de configuration des haricots au printemps 3.x
Une brève discussion sur la différence entre le singleton haricot et le singleton de printemps
Explication détaillée du cycle de vie de l'utilisation de la configuration du printemps
S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!