Primavera: @Component contro @Bean

Comprendo che @Component annotazione @Component stata introdotta nella spring 2.5 al fine di eliminare la definizione del bean xml utilizzando la scansione del classpath.

@Bean stato introdotto nella spring 3.0 e può essere utilizzato con @Configuration per eliminare completamente il file xml e utilizzare invece java config.

Sarebbe stato ansible riutilizzare l’annotazione @Component invece di introdurre l’annotazione @Bean ? La mia comprensione è che l’objective finale è creare fagioli in entrambi i casi.

@Component e @Component fanno due cose completamente diverse e non devono essere confusi.

@Component (e @Service e @Repository ) vengono utilizzati per rilevare e configurare automaticamente i bean utilizzando la scansione del percorso di class. Esiste un mapping uno-a-uno implicito tra la class annotata e il bean (ovvero un bean per class). Il controllo del cablaggio è piuttosto limitato con questo approccio, poiché è puramente dichiarativo.

@Bean è usato per dichiarare esplicitamente un singolo bean, piuttosto che lasciare che Spring lo faccia automaticamente come sopra. Scollega la dichiarazione del bean dalla definizione della class e consente di creare e configurare i bean esattamente come si sceglie.

Per rispondere alla tua domanda …

sarebbe stato ansible riutilizzare l’annotazione @Component invece di introdurre l’annotazione @Bean ?

Certo, probabilmente; ma hanno scelto di non farlo, dal momento che i due sono piuttosto diversi. La spring è già abbastanza confusa senza intaccare ulteriormente le acque.

@Component Preferibile per la scansione dei componenti e il cablaggio automatico.

Quando dovresti usare @Bean ?

A volte la configurazione automatica non è un’opzione. Quando? Immaginiamo di voler colbind componenti da librerie di terze parti (non hai il codice sorgente, quindi non puoi annotare le sue classi con @Component), quindi la configurazione automatica non è ansible.

L’annotazione @Bean restituisce un object che spring dovrebbe registrare come bean nel contesto dell’applicazione. Il corpo del metodo porta la logica responsabile della creazione dell’istanza.

Consideriamo che voglio un’implementazione specifica in base a qualche stato dinamico. @Bean è perfetto per quel caso.

 @Bean @Scope("prototype") public SomeService someService() { switch (state) { case 1: return new Impl1(); case 2: return new Impl2(); case 3: return new Impl3(); default: return new Impl(); } } 

Tuttavia non c’è modo di farlo con @Component .

Entrambi gli approcci mirano a registrare il tipo di bersaglio nel contenitore Spring.

La differenza è che @Bean è applicabile ai metodi , mentre @Component è applicabile ai tipi .

Pertanto, quando si utilizza l’annotazione @Bean si controlla la logica di creazione dell’istanza nel corpo del metodo (vedere l’ esempio sopra ). Con @Component annotazione @Component non puoi.

Quando si utilizza il tag @Component , è come avere un POJO (Plain Old Java Object) con un metodo di dichiarazione del bean vanilla (annotato con @Bean ). Ad esempio, il seguente metodo 1 e 2 darà lo stesso risultato.

Metodo 1

 @Component public class SomeClass { private int number; public SomeClass(Integer theNumber){ this.number = theNumber.intValue(); } public int getNumber(){ return this.number; } } 

con un bean per ‘theNumber’:

 @Bean Integer theNumber(){ return new Integer(3456); } 

Metodo 2

 //Note: no @Component tag public class SomeClass { private int number; public SomeClass(Integer theNumber){ this.number = theNumber.intValue(); } public int getNumber(){ return this.number; } } 

con i fagioli per entrambi:

 @Bean Integer theNumber(){ return new Integer(3456); } @Bean SomeClass someClass(Integer theNumber){ return new SomeClass(theNumber); } 

Il Metodo 2 ti permette di mantenere insieme le dichiarazioni dei bean, è un po ‘più flessibile, ecc. Potresti anche voler aggiungere un altro bean SomeClass non vanilla come il seguente:

 @Bean SomeClass strawberryClass(){ return new SomeClass(new Integer(1)); } 
  1. @Component rileva e configura i bean utilizzando la scansione del percorso di class dove @Bean dichiara esplicitamente un singolo bean, invece di lasciare che Spring lo faccia automaticamente.
  2. @Component non disaccoppia la dichiarazione del bean dalla definizione della class dove @Bean disaccoppia la dichiarazione del bean dalla definizione della class.
  3. @Component è un’annotazione di livello di class dove @Bean è un’annotazione a livello di metodo e il nome del metodo funge da nome bean.
  4. @Component non deve essere utilizzato con l’ annotazione @Configuration dove l’annotazione @Bean deve essere utilizzata all’interno della class annotata con @Configuration .
  5. Non possiamo creare un bean di una class usando @Component, se la class è al di fuori del contenitore di spring, dove possiamo creare un bean di una class usando @Bean anche se la class è presente al di fuori del contenitore spring .
  6. @Component ha diverse specializzazioni come @ Controller, @ Repository e @Service dove @Bean non ha specializzazioni .
  • @component e le sue specializzazioni (@Controller, @service, @repository) consentono il rilevamento automatico utilizzando la scansione del percorso di class. Se vediamo la class del componente come @Controller, @service, @repository verrà scansionato automaticamente dal framework spring usando la scansione del componente.
  • @Bean d’altra parte può essere utilizzato solo per dichiarare esplicitamente un singolo bean in una class di configurazione.
  • @Bean usato per dichiarare esplicitamente un singolo bean, piuttosto che lasciare che lo faccia automaticamente. La sua dichiarazione di fagiolo settato dalla definizione della class.
  • In breve @Controller, @service, @repository sono per il rilevamento automatico e @Bean per creare il bean seprate dalla class
     - @Controller
     LoginController di class pubblica 
     { --codice-- }

     - @Configuration
     AppConfig di class pubblica {
     @Fagiolo
     public SessionFactory sessionFactory () 
     {--codice-- }

@Component Questa è un’annotazione generica e può essere applicata a qualsiasi class dell’applicazione per renderla un componente gestito in spring (semplicemente, lo stereotipo generico per qualsiasi componente gestito a molla). quando il classpath viene scansionato dalla funzione component-scan di Spring (@ComponentScan) , identifica le classi annotate con annotazione @Component (all’interno del pacchetto specificato) e crea i bean di tali classi e li registra in ApplicationContext. @Component è un’annotazione di livello di class e il suo scopo è quello di rendere la class come componente gestito in spring e bean auto-rilevabile per la funzione di scansione del percorso di class.

se vuoi saperne di più su @Component e altre annotazioni sugli stereotipi, ti consigliamo di guardare questo articolo.

@Bean viene utilizzato per dichiarare e registrare esplicitamente un bean (come bean di configurazione) nel contenitore IOC di Spring restituito da un metodo. @Bean è un’annotazione a livello di metodo e viene utilizzata all’interno di una class annotata con @Configuration . Semplicemente, l’annotazione @Bean viene utilizzata per registrare il bean restituito da un metodo come bean di configurazione spring in Container IOC. @Bean è solo un’annotazione a livello di metodo e non può essere utilizzata con le classi e la dichiarazione dell’object.

L’ annotazione @Bean indica che un metodo produce un bean che deve essere gestito dal contenitore Spring.

Per dichiarare un bean, annota semplicemente un metodo con l’annotazione @Bean . Quando JavaConfig incontra un tale metodo, eseguirà quel metodo e registrerà il valore restituito come bean all’interno di ApplicationContext. Per impostazione predefinita, il nome del bean sarà uguale al nome del metodo. Quello che segue è un semplice esempio di una dichiarazione del metodo @Bean.

 @Configuration public class ApplicationConfig { @Bean public User adminUserProfile() { return new User("Rami","Nassar"); } } 

Nella class ApplicationConfig, puoi vedere che per prima cosa utilizziamo l’annotazione @Configuration per informare Spring che si tratta di un file di configurazione basato su Java. Successivamente, l’annotazione @Bean viene utilizzata per dichiarare un bean Spring e i requisiti DI. L’annotazione @Bean è equivalente a tag, il nome del metodo è equivalente all’attributo id all’interno di etichetta. Spero che dopo aver letto questo articolo, abbiate una chiara idea circa lo scopo reale e l’uso delle annotazioni @Bean e @Component .