Diferença entre usar o id e o nome do bean no arquivo de configuração do Spring

Existe alguma diferença entre usar um idatributo e um nameatributo em um <bean>elemento em um arquivo de configuração do Spring?

A partir da referência do Spring , 3.2.3.1 Naming Beans :

Todo bean possui um ou mais IDs (também chamados de identificadores ou nomes; esses termos se referem à mesma coisa). Esses IDs devem ser exclusivos dentro do contêiner no qual o bean está hospedado. Um bean quase sempre terá apenas um ID, mas se um bean tiver mais de um ID, os extras podem essencialmente ser considerados aliases.

Ao usar metadados de configuração baseados em XML, você usa os atributos 'id' ou 'name' para especificar os identificadores de bean. O atributo 'id' permite especificar exatamente um ID e, como é um atributo real do ID do elemento XML, o analisador XML pode fazer alguma validação extra quando outros elementos referenciarem o ID; como tal, é a maneira preferida de especificar um ID de bean. No entanto, a especificação XML limita os caracteres legais em IDs XML. Geralmente, isso não é uma restrição, mas se você precisar usar um desses caracteres XML especiais ou quiser introduzir outros aliases no bean, você também pode especificar um ou mais IDs de bean, separados por vírgula (, ), ponto-e-vírgula (;) ou espaço em branco no atributo 'nome'.

Então, basicamente, o idatributo está em conformidade com os padrões de atributo de identificação XML, enquanto nameé um pouco mais flexível. De um modo geral, eu uso namepraticamente exclusivamente. Parece apenas mais "primavera-y".

Desde a Primavera 3.1, o idatributo é um xsd:stringe permite o mesmo intervalo de caracteres que o nameatributo.

A única diferença entre an ide a nameé que a namepode conter vários aliases separados por vírgula, ponto e vírgula ou espaço em branco, enquanto que um iddeve ser um valor único.

Na documentação do Spring 3.2:

Nos metadados de configuração baseados em XML, você usa os atributos id e / ou name para especificar os identificadores de bean. O atributo id permite especificar exatamente um ID. Convencionalmente, esses nomes são alfanuméricos ('myBean', 'fooService' etc.), mas também podem ter caracteres especiais. Se você deseja introduzir outros aliases no bean, também pode especificá-los no atributo name, separados por vírgula (,), ponto-e-vírgula (;) ou espaço em branco. Como uma nota histórica, nas versões anteriores ao Spring 3.1, o atributo id foi digitado como um xsd: ID, que restringia possíveis caracteres. A partir da versão 3.1, agora é xsd: string. Observe que a exclusividade do ID do bean ainda é imposta pelo contêiner, embora não seja mais pelos analisadores XML.

Qualquer um funcionaria. Depende de suas necessidades:
se o identificador de seu bean contiver caracteres especiais, por exemplo ( /viewSummary.html), ele não será permitido como o bean id, porque não é um ID XML válido. Nesses casos, você pode pular a definição do bean ide fornecê-lo name.
O nameatributo também ajuda na definição de aliases para seu bean, pois permite especificar vários identificadores para um determinado bean.

Existe alguma diferença entre usar um atributo id e o atributo name em uma tag <bean>

Existem poucas pequenas diferenças, como usar id lançará uma exceção se não for tratado adequadamente.
deixe-me responder abaixo pergunta

Existe alguma diferença entre usar um atributo id e usar um atributo name em uma tag <bean>,

Não há diferença. você experimentará o mesmo efeito quando id ou nome for usado em uma tag <bean>.

Quão?

Os atributos id e name estão nos fornecendo um meio de fornecer valor de identificador a um bean (neste momento, pense id significa id, mas não identificador). Nos dois casos, você verá o mesmo resultado se ligar applicationContext.getBean("bean-identifier"); .

Tome @Bean, o equivalente java da tag <bean>, você não encontrará um atributo id. você pode atribuir seu valor de identificador ao @Bean apenas por meio do atributo name.

Deixe-me explicar através de um exemplo:
Pegue este arquivo de configuração, vamos chamá-lo como 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 retorna o objeto Foo para Foo f = (Foo) context.getBean("foo"); ,. Substitua id="foo"por name="foo"no spring1.xml acima, você ainda verá o mesmo resultado.

Defina sua configuração xml como,

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

Você receberá BeanDefinitionParsingException. Ele dirá que o nome do bean 'fooIdentifier' já está sendo usado nesse elemento. A propósito, esta é a mesma exceção que você verá se tiver abaixo da configuração
<bean name = "fooIdentifier" class = "com.intertech.Foo"> </bean>
<bean name = "fooIdentifier" class = "com. intertech.Foo "> </bean>


Se você mantiver id e nome na tag do bean, diz-se que o bean possui 2 identificadores. você pode obter o mesmo bean com qualquer identificador. tomar configuração como

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

o código a seguir imprime 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

Existe diferença na definição de ID e nome no xml do ApplicationContext? Não A partir de 3.1 (spring), id também é definido como um tipo xsd: string. Isso significa que os caracteres permitidos na definição do nome também são permitidos no ID. Isso não era possível antes da Primavera 3.1.

Por que usar o nome quando é o mesmo que Id? É útil para algumas situações, como permitir que cada componente em um aplicativo se refira a uma dependência comum usando um nome de bean específico para esse componente.

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

Ambos ide namesão identificadores de feijão na mola COI recipiente / ApplicationContecxt. O idatributo permite especificar exatamente um ID, mas usando o nameatributo, você pode atribuir um nome alternativo a esse bean.

Você pode conferir o documento da primavera aqui.