Interfacce BeanNameAware e BeanFactoryAware in primavera

1. Panoramica

In questo breve tutorial, ci concentreremo sulle interfacce BeanNameAware e BeanFactoryAware , in Spring Framework .

Descriveremo ciascuna interfaccia separatamente con i pro ei contro del loro utilizzo.

2. Interfaccia consapevole

Sia BeanNameAware che BeanFactoryAware appartengono all'interfaccia del marker root org.springframework.beans.factory.Aware . Utilizza l'inserimento del setter per ottenere un oggetto durante l'avvio del contesto dell'applicazione.

L' interfaccia Aware è un mix di modelli di design callback, listener e observer . Indica che il bean è idoneo a ricevere una notifica dal contenitore Spring tramite i metodi di callback.

3. BeanNameAware

BeanNameAware rende l'oggetto consapevole del nome del bean definito nel contenitore .

Diamo un'occhiata a un esempio:

public class MyBeanName implements BeanNameAware { @Override public void setBeanName(String beanName) { System.out.println(beanName); } }

La proprietà beanName rappresenta l'id bean registrato nel contenitore Spring. Nella nostra implementazione, stiamo semplicemente visualizzando il nome del bean.

Successivamente, registriamo un bean di questo tipo in una classe di configurazione Spring:

@Configuration public class Config { @Bean(name = "myCustomBeanName") public MyBeanName getMyBeanName() { return new MyBeanName(); } }

Qui abbiamo assegnato esplicitamente un nome alla nostra classe MyBeanName con la riga @Bean (name = “myCustomBeanName”) .

Ora possiamo avviare il contesto dell'applicazione e ottenere il bean da esso:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class); MyBeanName myBeanName = context.getBean(MyBeanName.class);

Come ci aspettiamo, il metodo setBeanName stampa "myCustomBeanName" .

Se rimuoviamo il codice name = "..." dall'annotazione @Bean, il contenitore, in questo caso, assegna il nome del metodo getMyBeanName () nel bean. Quindi l'output sarà "getMyBeanName" .

4. BeanFactoryAware

BeanFactoryAware viene utilizzato per iniettare l' oggetto BeanFactory . In questo modo abbiamo accesso a BeanFactory che ha creato l'oggetto.

Ecco un esempio di una classe MyBeanFactory :

public class MyBeanFactory implements BeanFactoryAware { private BeanFactory beanFactory; @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; } public void getMyBeanName() { MyBeanName myBeanName = beanFactory.getBean(MyBeanName.class); System.out.println(beanFactory.isSingleton("myCustomBeanName")); } }

Con l'aiuto del metodo setBeanFactory () , assegniamo il riferimento BeanFactory dal contenitore IoC alla proprietà beanFactory .

Dopodiché, possiamo usarlo direttamente come nella funzione getMyBeanName () .

Inizializziamo MyBeanFactory e chiamiamo il metodo getMyBeanName () :

MyBeanFactory myBeanFactory = context.getBean(MyBeanFactory.class); myBeanFactory.getMyBeanName();

Poiché abbiamo già istanziato la classe MyBeanName nell'esempio precedente, Spring richiamerà qui l'istanza esistente.

La riga beanFactory.isSingleton ("myCustomBeanName") lo verifica.

5. Quando usarlo?

Il caso d'uso tipico per BeanNameAware potrebbe essere l'acquisizione del nome del bean per scopi di registrazione o cablaggio. Per BeanFactoryAware potrebbe essere la possibilità di utilizzare un bean di primavera dal codice legacy.

Nella maggior parte dei casi, dovremmo evitare di utilizzare le interfacce Aware , a meno che non ne abbiamo bisogno. L'implementazione di queste interfacce accoppierà il codice al framework Spring.

6. Conclusione

In questo articolo, abbiamo appreso le interfacce BeanNameAware e BeanFactoryAware e come utilizzarle nella pratica.

Come al solito, il codice completo di questo articolo è disponibile su GitHub.