Différence entre l'utilisation de l'id et du nom du bean dans le fichier de configuration Spring
Existe-t-il une différence entre l’attribut id et l’attribut name sur un <bean> élément dans un fichier de configuration Spring?
À partir de référence de printemps , .2.3.1 Beans de nom :
Chaque bean a un ou plusieurs identifiants (également appelés identificateurs, ou noms; ces termes désignent la même chose). Ces identifiants doivent être uniques dans le conteneur dans lequel le bean est hébergé. Un bean n'a presque toujours qu'un identifiant, mais si un bean a plusieurs identifiants, ceux qui le sont en plus peuvent être considérés comme des alias.
Lorsque vous utilisez des métadonnées de configuration basées sur XML, vous utilisez les attributs "id" ou "name" pour spécifier le ou les identificateurs de bean. L'attribut 'id' vous permet de spécifier exactement un identifiant, et comme il s'agit d'un attribut réel d'ID d'élément XML, l'analyseur XML peut effectuer une validation supplémentaire lorsque d'autres éléments font référence à l'identifiant; En tant que tel, il est recommandé de spécifier un identifiant de bean. Cependant, la spécification XML limite les caractères qui sont légaux dans les ID XML. Ce n'est généralement pas une contrainte, mais si vous avez besoin d'utiliser l'un de ces caractères XML spéciaux, ou si vous souhaitez introduire d'autres alias dans le bean, vous pouvez également ou plutôt spécifier un ou plusieurs identifiants de bean, séparés par une virgule (, ), point-virgule (;) ou espaces dans l'attribut 'name'.
Donc, en gros, l'attribut id est conforme aux normes d'attribut XML id, tandis que name est un peu plus flexible. De manière générale, j’utilise name à peu près exclusivement. Cela semble juste plus "Spring-y".
Depuis Spring 3.1, l’attribut id est un xsd:string et autorise la même plage de caractères que l'attribut name.
La seule différence entre un id et un name est qu'un name peut contenir plusieurs alias séparés par une virgule, un point-virgule ou un espace, alors qu'un id doit être une valeur unique.
À partir de la documentation de Spring 3.2:
Dans les métadonnées de configuration basées sur XML, vous utilisez les attributs id et/ou name pour spécifier le ou les identificateurs de bean. L'attribut id vous permet de spécifier exactement un identifiant. Classiquement, ces noms sont alphanumériques ('myBean', 'fooService', etc.), mais peuvent également contenir des caractères spéciaux. Si vous souhaitez introduire d'autres alias dans le bean, vous pouvez également les spécifier dans l'attribut name, séparés par une virgule (,), un point-virgule (;) ou un espace. En tant que note historique, dans les versions antérieures à Spring 3.1, l'attribut id était saisi sous la forme d'un xsd: ID, qui contraignait les caractères possibles. À partir de la version 3.1, il s'agit maintenant de xsd: string. Notez que l'unicité des identifiants de bean est toujours appliquée par le conteneur, mais plus par les analyseurs XML.
L'un ou l'autre fonctionnerait. Cela dépend de vos besoins:
Si votre identifiant de bean contient des caractères spéciaux, par exemple (/viewSummary.html), il ne sera pas autorisé comme bean id, car ce n'est pas un identifiant XML valide. Dans de tels cas, vous pouvez ignorer la définition du bean id et fournir le bean name à la place.
L'attribut name aide également à définir aliases pour votre bean, car il permet de spécifier plusieurs identifiants pour un bean donné.
Existe-t-il une différence dans la définition de l'identifiant et du nom dans ApplicationContext XML? Non À partir de 3.1 (spring), id est également défini comme un type xsd: string. Cela signifie que tous les caractères autorisés dans la définition du nom sont également autorisés dans Id. Ce n'était pas possible avant le printemps 3.1.
Pourquoi utiliser name quand c'est identique à id? Cela est utile dans certaines situations, comme permettre à chaque composant d'une application de faire référence à une dépendance commune en utilisant un nom de bean spécifique à ce composant.
For example, the configuration metadata for subsystem A may refer to a DataSource via the name subsystemA-dataSource. The configuration metadata for subsystem B may refer to a DataSource via the name subsystemB-dataSource. When composing the main application that uses both these subsystems the main application refers to the DataSource via the name myApp-dataSource. To have all three names refer to the same object you add to the MyApp configuration metadata the following
<bean id="myApp-dataSource" name="subsystemA-dataSource,subsystemB-dataSource" ..../>
Alternatively, You can have separate xml configuration files for each sub-system and then you can make use of
alias to define your own names.
<alias name="subsystemA-dataSource" alias="subsystemB-dataSource"/>
<alias name="subsystemA-dataSource" alias="myApp-dataSource" />
Y a-t-il une différence entre utiliser un attribut id et un attribut name sur une balise <bean>
Il existe peu de différences mineures, par exemple, utiliser id lancera une exception s’il n’est pas traité correctement.
permettez-moi de répondre à la question ci-dessous
Existe-t-il une différence entre en utilisant un id attribut et en utilisant un nom attribut sur une balise <bean>,
Il n'y a pas de différence. vous obtiendrez le même effet lorsque id ou name est utilisé sur une balise <bean>.
Comment?
Les attributs id et name nous donnent le moyen de fournir un identifiant à un bean particulier (pour le moment, think id signifie id mais pas en tant qu'identifiant). vous pouvez choisir n'importe quel attribut pour fournir une valeur d'identifiant. Dans les deux cas, vous obtiendrez le même résultat si vous appelez applicationContext.getBean("bean-identifier");.
Prenez @Bean, la balise Java équivalente à <bean>, il n'y a pas d'attribut id. Vous pouvez attribuer à votre identifiant la valeur uniquement via l'attribut name.
Laissez-moi vous expliquer à travers un exemple, considérons le code suivant pour obtenir un haricot,FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(...); Foo f = (Foo) context.getBean("foo")// returns Foo object;
Si la configuration est fournie en tant que
spring1.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
<bean id="foo" class="com.intertech.Foo"></bean>
<bean id="bar" class="com.intertech.Bar"></bean>
</beans>
Spring renvoie l'objet Foo pour, Foo f = (Foo) context.getBean("foo");
remplacez id="foo" par name="foo" dans le fichier spring1.xml ci-dessus
Vous pouvez toujours voir le même résultat,
Spring renvoie l'objet Foo pour, Foo f = (Foo) context.getBean("foo");
Définissez votre configuration XML comme,
<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
<bean id="fooIdentifier" class="com.intertech.Foo"></bean>
<bean name="fooIdentifier" class="com.intertech.Foo"></bean>
</beans>
Vous obtiendrez BeanDefinitionParsingException, le nom de bean 'fooIdentifier' est déjà utilisé dans cet élément.
La même exception sera levée si
<nom de bean = "fooIdentifier" class = "com.intertech.Foo"> </ bean>
<nom de bean = "fooIdentifier" class = "com.intertech.Foo"> </ bean>
est passé comme configuration
Si vous conservez l'identifiant et le nom dans la balise de bean, le bean est dit avoir 2 identifiants, vous pouvez obtenir le même bean avec n'importe quel identifiant. prendre config comme
<?xml version="1.0" encoding="UTF-8"?><br>
<beans ...>
<bean id="fooById" name="fooByName" class="com.intertech.Foo"></bean>
<bean id="bar" class="com.intertech.Bar"></bean>
</beans>
le code suivant affiche true
FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(...);
Foo fooById = (Foo) context.getBean("fooById")// returns Foo object;
Foo fooByName = (Foo) context.getBean("fooByName")// returns Foo object;
System.out.println(fooById == fooByName) //true