Lifeciclo di fagioli primaverili
Il ciclo di vita del fagiolo di primavera ha numerosi passi come inizializzazione, corsa e distruggere. Possiamo eseguire il nostro compito personalizzato tra queste fasi per test/debug o altri scopi di utilità.
Per esempio, Se vogliamo svolgere alcune attività all'inizio del fagiolo e alcune attività correlate alla fine, possiamo farlo all'inizializzazione del fagio. Rende l'applicazione più funzionale e anche più facile da eseguire il debug.
A tale scopo, Spring fornisce alcuni predefiniti Interfacce e annotazioni Questo rende il nostro compito facile. Esistono due modi per svolgere questi compiti:
- Interfacce
- Annotazioni
Innanzitutto, iniziamo con le interfacce e poi esaminiamo le annotazioni.
Interfacce per il ciclo di vita di java bean
Spring ha due interfacce, InitializingBean E Monouso, che contiene diversi metodi di utilità per eseguire le attività durante il ciclo di vita del fagiolo.
Per eseguire l'attività di inizializzazione, possiamo usare afterpropertiesset () metodo del InitializingBean interfaccia in modo simile per la pulizia delle risorse. Prima di distruggere l'oggetto fagiolo, possiamo usare il distruggere() metodo del Monouso interfaccia.
Cominciamo con esempi in esecuzione.
Implementazione di metodi di ciclo di vita utilizzando le interfacce
In questo caso, in primo luogo, creiamo un'applicazione a molla con sede a Maven e quindi creiamo un dipendente di Bean. Questa classe di fagioli implementa entrambe le interfacce di cui abbiamo discusso. Ora, dobbiamo implementare anche i loro metodi.
IL afterpropertiesset () il metodo viene utilizzato per eseguire l'attività di inizializzazione e il distruggere() metodo per eseguire l'attività prima di distruggere l'oggetto bean. Vedi il codice sorgente della classe dei bean dipendenti.
// dipendente.Giava
importorg.Springframework.fagioli.fabbrica.Monouso;
importorg.Springframework.fagioli.fabbrica.InitializingBean;
importorg.Springframework.stereotipo.Componente;
@Component ("EMP")
PublicClass Employee ImplementInitializingBean, usa e getta
privateIntid;
Nome stringa privato;
public String getName ()
returnname;
publicVoidSetName (nome stringa)
Questo.nome = nome;
publicIntgetId ()
returnid;
publicVoidSetId (intid)
Questo.id = id;
@Oltrepassare
publicvoidAfterPropertieSesst () lancia un'eccezione
Sistema.fuori.println ("Compiti di inizializzazione svolti ...");
@Oltrepassare
publicvoidDestroy () lancia un'eccezione
Sistema.fuori.println ("compiti di pulizia svolti ... \ nbean oggetto distrutto!");
Questa è la classe principale in cui istanziamo il fagiolo e chiamiamo il metodo di getter e setter.
// Springapp.Giava
pacchetto com.Linuxhint;Org di importazione.Springframework.contesto.annotazione.AnnotationConfigApplicationContext;
Importa com.Linuxhint.fagioli.Dipendente;
Classe pubblica Springapp
public static void main (string [] args)
AnnotationConfigApplicationContext AC = new AnnotationConfigApplicationContext (SpringConfig.classe);
Emp Emp = (dipendente) AC.getbean ("emp");
Emp.setName ("Rohan");
Sistema.fuori.println ("Esecuzione di fagioli ...");
Nome stringa = emp.getName ();
Sistema.fuori.println ("nome:"+nome);
AC.vicino();
// SpringConfig.Giava
packagecom.Linuxhint;importorg.Springframework.contesto.annotazione.Componentscan;
importorg.Springframework.contesto.annotazione.Configurazione;
@Configurazione
@Componentscan ("com.Linuxhint.*")
publicclassspringconfig
// pom.XML
Questo è il file XML che contiene tutto il codice di dipendenza per l'applicazione.
Esegui il progetto
Dopo aver creato il progetto, è tempo di eseguire l'applicazione per verificare se tutti i file funzionano bene e l'applicazione funziona come previsto. Questa applicazione stampa il seguente output sulla finestra della console:
Produzione:
Inizializzazione delle attività svolte ..Bean che esegue ..
Nome: Rohan
Compiti di pulizia svolti ..
Oggetto bean distrutto!
Avviso: Non abbiamo chiamato i metodi del ciclo di vita ma implicitamente chiamato Spring Conteiner (IOC).
Implementazione di metodi di ciclo di vita utilizzando annotazioni
Questo è l'approccio moderno in cui utilizziamo le annotazioni su interfacce. Ciò significa che non sono necessarie più interfacce per essere implementate dalla classe Bean. Dobbiamo solo contrassegnare i metodi da chiamare usando le annotazioni @PostConstruct e @preDestroy.
L'annotazione @PostConstruct viene chiamata al momento dell'inizializzazione mentre il @preDestroy viene chiamato appena prima di distruggere l'oggetto bean.
Nota: Prima di utilizzare le annotazioni, dobbiamo aggiungere la seguente dipendenza al POM del nostro progetto.file XML.
Questo pacchetto non è presente nel pacchetto Spring predefinito. Quindi, per le versioni Java 9 e più alte, metti questi barattoli nel pom.File XML:
Spring non fornisce alcun metodo predefinito come nel caso di interfaccia. Siamo liberi di creare qualsiasi metodo con qualsiasi nome. Dobbiamo solo contrassegnarli con le annotazioni per specificare quando chiamarli dal contenitore IOC.
Qui, creiamo il metodo initwork () per eseguire l'attività a livello iniziale e il metodo endwork () per eseguire l'attività prima di distruggere l'oggetto bean.
Aggiorna il Dipendente.Giava File in base al seguente codice sorgente:
// Dipendente.Giava
importjavax.annotazione.Postconstruct;
importjavax.annotazione.Predetroy;
importorg.Springframework.stereotipo.Componente;
@Component ("EMP")
impiegato di publicclass
privateIntid;
Nome stringa privato;
public String getName ()
returnname;
publicVoidSetName (nome stringa)
Questo.nome = nome;
publicIntgetId ()
returnid;
publicVoidSetId (intid)
Questo.id = id;
@Postconstruct
publicVoidInitWork ()
Sistema.fuori.println ("Compiti di inizializzazione svolti ...");
@PreDestroy
publicVoidendWork ()
Sistema.fuori.println ("compiti di pulizia svolti ... \ nbean oggetto distrutto!");
Esegui il progetto
Ora, esegui di nuovo l'applicazione e controlla la console. L'output dovrebbe essere simile all'output precedente.
Inizializzazione delle attività svolte ..Bean che esegue ..
Nome: Rohan
Compiti di pulizia svolti ..
Oggetto bean distrutto!