Differenza tra l'utilizzo dell'ID bean e il nome nel file di configurazione di Spring

C'è qualche differenza tra l'uso di un idattributo e un nameattributo su un <bean>elemento in un file di configurazione di Spring?

Dal riferimento di primavera , 3.2.3.1 Naming Beans :

Ogni bean ha uno o più ID (chiamati anche identificatori o nomi; questi termini si riferiscono alla stessa cosa). Questi ID devono essere univoci all'interno del contenitore in cui è ospitato il bean. Un bean avrà quasi sempre un solo ID, ma se un bean ha più di un ID, quelli extra possono essere essenzialmente considerati alias.

Quando si utilizzano metadati di configurazione basati su XML, si utilizzano gli attributi 'id' o 'name' per specificare gli identificativi del bean. L'attributo 'id' ti consente di specificare esattamente un id, e dato che è un vero attributo ID elemento XML, il parser XML è in grado di fare qualche validazione extra quando altri elementi fanno riferimento all'id; come tale, è il modo preferito per specificare un ID bean. Tuttavia, la specifica XML limita i caratteri legali negli ID XML. Questo di solito non è un vincolo, ma se hai bisogno di usare uno di questi caratteri XML speciali o vuoi introdurre altri alias nel bean, puoi anche o invece specificare uno o più ID bean, separati da una virgola (, ), punto e virgola (;) o spazio bianco nell'attributo 'nome'.

Quindi, in sostanza, l' idattributo è conforme agli standard dell'attributo id XML mentre nameè un po 'più flessibile. In generale, uso namequasi esclusivamente. Sembra solo più "Primavera-y".

Dalla primavera 3.1 l' idattributo è un xsd:stringe consente lo stesso intervallo di caratteri namedell'attributo.

L'unica differenza tra an ide a nameè che a namepuò contenere più alias separati da una virgola, un punto e virgola o uno spazio bianco, mentre un iddeve essere un valore singolo.

Dalla documentazione di Spring 3.2:

Nei metadati di configurazione basati su XML, si utilizzano gli attributi id e / o name per specificare gli identificativi del bean. L'attributo id consente di specificare esattamente un ID. Convenzionalmente questi nomi sono alfanumerici ("myBean", "fooService", ecc.), Ma possono anche contenere caratteri speciali. Se si desidera introdurre altri alias nel bean, è possibile specificarli anche nell'attributo name, separati da una virgola (,), punto e virgola (;) o spazio bianco. Come nota storica, nelle versioni precedenti alla primavera 3.1, l'attributo id è stato digitato come xsd: ID, che vincolava possibili caratteri. A partire da 3.1, ora è xsd: string. Si noti che l'unicità dell'ID bean è ancora applicata dal contenitore, sebbene non più dai parser XML.

O uno funzionerebbe. Dipende dalle vostre esigenze:
se l'identificatore del bean contiene caratteri speciali, ad esempio ( /viewSummary.html), non sarà consentito come bean id, poiché non è un ID XML valido. In questi casi è possibile saltare la definizione del bean ide fornire nameinvece il bean .
L' nameattributo aiuta anche a definire aliases per il tuo bean, poiché consente di specificare più identificatori per un determinato bean.

C'è qualche differenza tra l'uso di un attributo id e l'attributo name su un tag <bean>

Esistono poche differenze minori come, l'uso di id genererà eccezioni se non gestito correttamente.
lasciami rispondere sotto la domanda

C'è qualche differenza tra l' uso di un attributo id e l' uso di un attributo name su un tag <bean>,

Non c'è differenza. sperimenterai lo stesso effetto quando si usa id o name su un tag <bean>.

Come?

Entrambi gli attributi id e name ci stanno fornendo un mezzo per fornire il valore identificativo a un bean (per ora, pensa che id significhi id ma non identificatore). In entrambi i casi, vedrai lo stesso risultato se chiami applicationContext.getBean("bean-identifier"); .

Prendi @Bean, l'equivalente java del tag <bean>, non troverai un attributo id. puoi dare il valore del tuo identificatore a @Bean solo tramite l'attributo name.

Lasciatemi spiegare con un esempio:
prendete questo file di configurazione, chiamiamolo come 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>

Primavera torna oggetto Foo per, Foo f = (Foo) context.getBean("foo"); . Sostituisci id="foo"con name="foo"nel precedente spring1.xml, vedrai comunque lo stesso risultato.

Definisci la tua configurazione xml come,

<?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>

Otterrai BeanDefinitionParsingException. Dirà, il nome bean "fooIdentifier" è già utilizzato in questo elemento. A proposito, questa è la stessa eccezione che vedrai se hai sotto config
<bean name = "fooIdentifier" class = "com.intertech.Foo"> </bean>
<bean name = "fooIdentifier" class = "com. intertech.Foo "> </bean>


Se mantieni sia id che name per il tag bean, si dice che il bean abbia 2 identificatori. puoi ottenere lo stesso bean con qualsiasi identificatore. prendere config come

<?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>

il seguente codice viene stampato vero

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

C'è differenza nella definizione di ID e nome in ApplicationContext xml? No A partire da 3.1 (primavera), id è anche definito come un tipo xsd: string. Significa che qualunque carattere consentito nella definizione del nome è consentito anche in Id. Questo non era possibile prima della primavera 3.1.

Perché usare il nome quando è uguale a ID? È utile per alcune situazioni, come consentire a ciascun componente di un'applicazione di fare riferimento a una dipendenza comune utilizzando un nome bean specifico per quel componente stesso.

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" />

Entrambi ide namesono identificatori di bean nel contenitore IOC Spring / ApplicationContecxt. L' idattributo consente di specificare esattamente un ID, ma utilizzando l' nameattributo è possibile assegnare un nome alias a quel bean.

Puoi consultare il documento di primavera qui.