Eseguire codice alla creazione o distruzione di un bean in Spring

Ci sono 3 modi per eseguire codice alla creazione di un bean in Spring:

  • con l’annotation @PostConstruct
  • implementando l’interfaccia InitializingBean
  • configurando la proprietà init-method

Il motivo per cui si esegue codice alla creazione di un bean è spesso quello di verificare le dipendenze, o assegnare loro un valore di default, o eseguire azioni automatiche come l’avvio di un task schedulato.
Il costruttore del bean potrebbe non essere adatto a questo scopo perchè il bean non è completamente inizializzato fino a quando il costruttore non ha completato.

In modo analogo ci sono 3 modi per eseguire codice alla distruzione di un bean in Spring:

  • con l’annotation @PreDestroy
  • implementando l’interfaccia DisposableBean
  • configurando la proprietà destroy-method

Normalmente questi metodi sono usati per liberare risorse come file aperti ma considera che sono chiamati solo per i singleton bean (un’unica istanza del bean per l’applicazione); nel caso di prototype bean è chiamato solo il metodo destroy dell’interfaccia DisposableBean.
In ogni caso è necessaria una esplicita chiamata a un metodo destroy (di AbstractApplicationContext o del bean), non è sufficiente che l’applicazione semplicemente finisca.
Un’alternativa è quella di utilizzare il metodo AbstractApplicationContext.registerShutdownHook() con il quale si crea un thread appena prima della chiusura dell’applicazione che chiama il metodo destroy di AbstractApplicationContext.
La seguente tabella mostra le possibili combinazioni:

singleton bean prototype bean
AbstractApplicationContext .destroy() @PreDestroy
DisposableBean.destroy()
destroy-method
nessun metodo
bean.destroy() DisposableBean.destroy() DisposableBean.destroy()
AbstractApplicationContext .registerShutdownHook() @PreDestroy
DisposableBean.destroy()
destroy-method
nessun metodo

Naturalmente non tutti i metodi devono essere implementati contemporaneamente ma è possibile scegliere quale utilizzare.

pro contro
metodi configurati in file .xml disaccoppiamento da Spring configurazione manuale di ogni bean
metodi ereditati da interfacce configurazione della sola classe, portabilità accoppiamento con Spring
metodi con annotation portabilità richiesto supporto per JSR-250

Per verificare tutto questo crea un nuovo progetto java:

  1. crea il file conf/app-context.xml

    la cartella “conf” deve essere nel classpath;
    la riga <context:annotation-config/> necessaria se usi le annotation
  2. crea il file conf/log4j.xml
  3. crea il file eu/lucazanini/mybean/Main.java

    la classe GenericXmlApplicationContext è una sottoclasse di AbstractApplicationContext
  4. crea il file eu/lucazanini/mybean/SimpleBean.java

L’output è il seguente:

Osserva che l’ordine con cui sono eseguiti i metodi è fisso:

  1. metodo da annotation (@PostConstruct e @PreDestroy)
  2. metodo da interfaccia (InitializingBean e DisposableBean)
  3. metodo da file .xml (init-method e destroy-method)

Commentando e decommentando alcune parti del file Main.java o sostituendo “singleton” con “prototype” come scope del bean in app-context.xml, puoi ottenere le varie situazioni mostrate in questo articolo.

Una risposta a “Eseguire codice alla creazione o distruzione di un bean in Spring”

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.