Primavera - Guida rapida

Spring è il framework di sviluppo di applicazioni più popolare per Java aziendale. Milioni di sviluppatori in tutto il mondo utilizzano Spring Framework per creare codice ad alte prestazioni, facilmente testabile e riutilizzabile.

Il framework Spring è una piattaforma Java open source. Inizialmente è stato scritto da Rod Johnson ed è stato rilasciato per la prima volta con la licenza Apache 2.0 nel giugno 2003.

La primavera è leggera quando si tratta di dimensioni e trasparenza. La versione base del framework Spring è di circa 2 MB.

Le funzionalità principali di Spring Framework possono essere utilizzate nello sviluppo di qualsiasi applicazione Java, ma esistono estensioni per la creazione di applicazioni Web sulla piattaforma Java EE. Il framework Spring mira a rendere lo sviluppo J2EE più facile da usare e promuove buone pratiche di programmazione abilitando un modello di programmazione basato su POJO.

Vantaggi dell'utilizzo di Spring Framework

Di seguito è riportato l'elenco di alcuni dei grandi vantaggi dell'utilizzo di Spring Framework:

• Spring consente agli sviluppatori di sviluppare applicazioni di classe enterprise utilizzando POJO. Il vantaggio di utilizzare solo POJO è che non è necessario un prodotto contenitore EJB come un server applicazioni, ma si ha la possibilità di utilizzare solo un contenitore servlet robusto come Tomcat o qualche prodotto commerciale.

• La primavera è organizzata in modo modulare. Anche se il numero di pacchetti e classi è notevole, devi preoccuparti solo di quelli che ti servono e ignorare il resto.

• Spring non reinventa la ruota, ma fa davvero uso di alcune delle tecnologie esistenti come diversi framework ORM, framework di registrazione, timer JEE, Quartz e JDK e altre tecnologie di visualizzazione.

• Testare un'applicazione scritta con Spring è semplice perché il codice dipendente dall'ambiente viene spostato in questo framework. Inoltre, utilizzando i POJO in stile JavaBean, diventa più facile utilizzare l'inserimento delle dipendenze per l'inserimento dei dati di test.

• Il framework web di Spring è un framework MVC web ben progettato, che fornisce un'ottima alternativa ai framework web come Struts o altri framework web troppo ingegnerizzati o meno popolari.

• Spring fornisce una comoda API per tradurre le eccezioni specifiche della tecnologia (lanciate da JDBC, Hibernate o JDO, ad esempio) in eccezioni coerenti e non controllate.

• I contenitori IoC leggeri tendono ad essere leggeri, soprattutto se paragonati ai contenitori EJB, ad esempio. Ciò è utile per lo sviluppo e la distribuzione di applicazioni su computer con memoria e risorse della CPU limitate.

• Spring fornisce un'interfaccia di gestione delle transazioni coerente che può scalare fino a una transazione locale (utilizzando un singolo database, ad esempio) e scalare fino a transazioni globali (utilizzando JTA, ad esempio).

Iniezione di dipendenza (DI)

La tecnologia con cui Spring si identifica maggiormente è la Dependency Injection (DI)sapore di inversione di controllo. IlInversion of Control (IoC)è un concetto generale e può essere espresso in molti modi diversi. Dependency Injection è solo un esempio concreto di inversione del controllo.

Quando si scrive un'applicazione Java complessa, le classi dell'applicazione dovrebbero essere il più indipendenti possibile da altre classi Java per aumentare la possibilità di riutilizzare queste classi e per testarle indipendentemente da altre classi durante il test unitario. Dependency Injection aiuta a incollare queste classi insieme e allo stesso tempo a mantenerle indipendenti.

Cos'è esattamente l'inserimento delle dipendenze? Diamo un'occhiata a queste due parole separatamente. Qui la parte di dipendenza si traduce in un'associazione tra due classi. Ad esempio, la classe A dipende dalla classe B. Ora, diamo un'occhiata alla seconda parte, l'iniezione. Tutto ciò significa che la classe B verrà iniettata nella classe A dall'IoC.

L'inserimento delle dipendenze può avvenire nel modo in cui si passano i parametri al costruttore o dopo la costruzione utilizzando metodi setter. Poiché l'inserimento delle dipendenze è il cuore di Spring Framework, spiegheremo questo concetto in un capitolo separato con esempi pertinenti.

Programmazione orientata agli aspetti (AOP)

Uno dei componenti chiave di Spring è il Aspect Oriented Programming (AOP)struttura. Vengono chiamate le funzioni che si estendono su più punti di un'applicazionecross-cutting concernse queste preoccupazioni trasversali sono concettualmente separate dalla logica di business dell'applicazione. Esistono vari buoni esempi comuni di aspetti tra cui registrazione, transazioni dichiarative, sicurezza, memorizzazione nella cache, ecc.

L'unità chiave della modularità in OOP è la classe, mentre in AOP l'unità di modularità è l'aspetto. DI ti aiuta a disaccoppiare gli oggetti dell'applicazione l'uno dall'altro, mentre AOP ti aiuta a disaccoppiare i problemi di cross-cutting dagli oggetti che influenzano.

Il modulo AOP di Spring Framework fornisce un'implementazione della programmazione orientata agli aspetti che consente di definire intercettori di metodi e pointcuts per disaccoppiare in modo pulito il codice che implementa funzionalità che dovrebbero essere separate. Discuteremo di più sui concetti di Spring AOP in un capitolo separato.

La primavera potrebbe potenzialmente essere uno sportello unico per tutte le applicazioni aziendali. Tuttavia, Spring è modulare, permettendoti di scegliere quali moduli sono applicabili a te, senza dover portare il resto. La sezione seguente fornisce dettagli su tutti i moduli disponibili in Spring Framework.

Spring Framework fornisce circa 20 moduli che possono essere utilizzati in base a un requisito dell'applicazione.

Contenitore principale

Il Core Container è costituito dai moduli Core, Beans, Context e Expression Language i cui dettagli sono i seguenti:

• Il Core Il modulo fornisce le parti fondamentali del framework, incluse le funzionalità IoC e Dependency Injection.

• Il Bean module fornisce BeanFactory, che è un'implementazione sofisticata del pattern factory.

• Il ContextIl modulo si basa sulla solida base fornita dai moduli Core e Beans ed è un mezzo per accedere a qualsiasi oggetto definito e configurato. L'interfaccia ApplicationContext è il punto focale del modulo Context.

• Il SpEL fornisce un potente linguaggio di espressione per interrogare e manipolare un oggetto grafico in fase di esecuzione.

Accesso / integrazione dei dati

Il livello di accesso / integrazione dei dati è costituito dai moduli JDBC, ORM, OXM, JMS e Transaction i cui dettagli sono i seguenti:

• Il JDBC Il modulo fornisce un livello di astrazione JDBC che elimina la necessità di noiose codifiche relative a JDBC.

• Il ORM fornisce livelli di integrazione per le API più diffuse di mappatura relazionale a oggetti, tra cui JPA, JDO, Hibernate e iBatis.

• Il OXM fornisce un livello di astrazione che supporta le implementazioni di mapping Object / XML per JAXB, Castor, XMLBeans, JiBX e XStream.

• Il servizio di messaggistica Java JMS Il modulo contiene funzionalità per produrre e consumare messaggi.

• Il Transaction Il modulo supporta la gestione delle transazioni programmatica e dichiarativa per le classi che implementano interfacce speciali e per tutti i POJO.

ragnatela

Il livello Web è costituito dai moduli Web, Web-MVC, Web-Socket e Web-Portlet i cui dettagli sono i seguenti:

• Il Web Il modulo fornisce funzionalità di integrazione orientate al web di base come la funzionalità di caricamento di file in più parti e l'inizializzazione del contenitore IoC utilizzando listener servlet e un contesto applicativo orientato al web.

• Il Web-MVC Il modulo contiene l'implementazione di Spring Model-View-Controller (MVC) per le applicazioni web.

• Il Web-Socket Il modulo fornisce il supporto per la comunicazione bidirezionale basata su WebSocket tra il client e il server nelle applicazioni web.

• Il Web-Portlet Il modulo fornisce l'implementazione MVC da utilizzare in un ambiente portlet e rispecchia la funzionalità del modulo Web-Servlet.

Miscellanea

Ci sono pochi altri moduli importanti come i moduli AOP, Aspects, Instrumentation, Web e Test i cui dettagli sono i seguenti:

• Il AOP Il modulo fornisce un'implementazione della programmazione orientata agli aspetti che consente di definire intercettori di metodi e pointcuts per disaccoppiare in modo pulito il codice che implementa funzionalità che dovrebbero essere separate.

• Il Aspects Il modulo fornisce l'integrazione con AspectJ, che è ancora una volta un framework AOP potente e maturo.

• Il Instrumentation Il modulo fornisce il supporto della strumentazione di classe e le implementazioni del programma di caricamento classi da utilizzare in determinati server delle applicazioni.

• Il MessagingIl modulo fornisce il supporto per STOMP come sottoprotocollo WebSocket da utilizzare nelle applicazioni. Supporta anche un modello di programmazione delle annotazioni per l'instradamento e l'elaborazione dei messaggi STOMP dai client WebSocket.

• Il Test Il modulo supporta il test dei componenti Spring con framework JUnit o TestNG.

Questo capitolo ti guiderà su come preparare un ambiente di sviluppo per iniziare a lavorare con Spring Framework. Ti insegnerà anche come configurare JDK, Tomcat ed Eclipse sulla tua macchina prima di configurare Spring Framework -

Passaggio 1: configurazione del Java Development Kit (JDK)

È possibile scaricare l'ultima versione di SDK dal sito Java di Oracle - Download di Java SE. Troverai le istruzioni per l'installazione di JDK nei file scaricati, segui le istruzioni fornite per installare e configurare il setup. Infine, impostare le variabili di ambiente PATH e JAVA_HOME in modo che facciano riferimento alla directory che contiene java e javac, tipicamente java_install_dir / bin e java_install_dir rispettivamente.

Se stai usando Windows e hai installato JDK in C: \ jdk1.6.0_15, dovresti inserire la seguente riga nel tuo file C: \ autoexec.bat.

set PATH=C:\jdk1.6.0_15\bin;%PATH% 
set JAVA_HOME=C:\jdk1.6.0_15

In alternativa, su Windows NT / 2000 / XP, dovrai fare clic con il pulsante destro del mouse su Risorse del computer, selezionare Proprietà → Avanzate → Variabili d'ambiente. Quindi, dovrai aggiornare il valore PATH e fare clic sul pulsante OK.

Su Unix (Solaris, Linux, ecc.), Se l'SDK è installato in /usr/local/jdk1.6.0_15 e utilizzi la shell C, dovrai inserire quanto segue nel tuo file .cshrc.

setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk1.6.0_15

In alternativa, se utilizzi un IDE (Integrated Development Environment) come Borland JBuilder, Eclipse, IntelliJ IDEA o Sun ONE Studio, dovrai compilare ed eseguire un semplice programma per confermare che l'IDE sa dove hai installato Java. Altrimenti, dovrai eseguire una corretta configurazione come indicato nel documento dell'IDE.

Passaggio 2: installare l'API di registrazione comune di Apache

Puoi scaricare l'ultima versione dell'API di registrazione di Apache Commons da https://commons.apache.org/logging/. Dopo aver scaricato l'installazione, decomprimere la distribuzione binaria in una posizione comoda. Ad esempio, in C: \ commons-logging-1.1.1 su Windows o /usr/local/commons-logging-1.1.1 su Linux / Unix. Questa directory conterrà i seguenti file jar e altri documenti di supporto, ecc.

Assicurati di impostare correttamente la tua variabile CLASSPATH su questa directory altrimenti dovrai affrontare un problema durante l'esecuzione dell'applicazione.

Passaggio 3: configurazione dell'IDE di Eclipse

Tutti gli esempi in questo tutorial sono stati scritti utilizzando Eclipse IDE. Quindi ti suggeriamo di avere l'ultima versione di Eclipse installata sulla tua macchina.

Per installare Eclipse IDE, scarica gli ultimi binari Eclipse da https://www.eclipse.org/downloads/. Dopo aver scaricato l'installazione, decomprimere la distribuzione binaria in una posizione comoda. Ad esempio, in C: \ eclipse su Windows o / usr / local / eclipse su Linux / Unix e infine impostare la variabile PATH in modo appropriato.

Eclipse può essere avviato eseguendo i seguenti comandi sulla macchina Windows, oppure puoi semplicemente fare doppio clic su eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse può essere avviato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

$/usr/local/eclipse/eclipse

Dopo un avvio riuscito, se tutto va bene, dovrebbe visualizzare il seguente risultato:

Passaggio 4: configurazione delle librerie di Spring Framework

Ora, se tutto va bene, puoi procedere alla configurazione del tuo framework Spring. Di seguito sono riportati i semplici passaggi per scaricare e installare il framework sul tuo computer.

• Scegli se installare Spring su Windows o Unix, quindi procedi al passaggio successivo per scaricare il file .zip per Windows e il file .tz per Unix.

• Scarica l'ultima versione dei binari del framework Spring da https://repo.spring.io/release/org/springframework/spring.

• Al momento dello sviluppo di questo tutorial, spring-framework-4.1.6.RELEASE-dist.zipè stato scaricato su macchina Windows. Dopo che il file scaricato è stato decompresso, fornisce la seguente struttura di directory all'interno di E: \ spring.

Troverai tutte le librerie Spring nella directory E:\spring\libs. Assicurati di impostare correttamente la tua variabile CLASSPATH su questa directory altrimenti dovrai affrontare un problema durante l'esecuzione dell'applicazione. Se stai utilizzando Eclipse, non è necessario impostare CLASSPATH perché tutte le impostazioni verranno eseguite tramite Eclipse.

Una volta che hai finito con questo ultimo passaggio, sei pronto per procedere al tuo primo esempio di primavera nel prossimo capitolo.

Cominciamo la programmazione vera e propria con Spring Framework. Prima di iniziare a scrivere il tuo primo esempio usando il framework Spring, devi assicurarti di aver impostato correttamente il tuo ambiente Spring come spiegato in Spring - Capitolo Configurazione dell'ambiente . Presumiamo inoltre che tu abbia un po 'di conoscenza di lavoro su Eclipse IDE.

Ora procediamo a scrivere una semplice applicazione Spring, che stamperà "Hello World!" o qualsiasi altro messaggio basato sulla configurazione eseguita nel file di configurazione Spring Beans.

Passaggio 1: creare un progetto Java

Il primo passo è creare un semplice progetto Java utilizzando Eclipse IDE. Segui l'opzioneFile → New → Project e infine seleziona Java Projectprocedura guidata dall'elenco delle procedure guidate. Ora assegna un nome al tuo progetto comeHelloSpring utilizzando la finestra della procedura guidata come segue:

Una volta che il tuo progetto è stato creato con successo, avrai il seguente contenuto nel tuo file Project Explorer -

Passaggio 2: aggiungere le librerie richieste

Come secondo passaggio, aggiungiamo Spring Framework e librerie API di registrazione comuni nel nostro progetto. Per fare ciò, fai clic con il pulsante destro del mouse sul nome del progettoHelloSpring e quindi seguire la seguente opzione disponibile nel menu contestuale: Build Path → Configure Build Path per visualizzare la finestra Percorso build Java come segue:

Ora usa Add External JARs pulsante disponibile sotto il Libraries scheda per aggiungere i seguenti JAR principali dalle directory di installazione di Spring Framework e Common Logging:

• commons-logging-1.1.1

• spring-aop-4.1.6.RELEASE

• spring-aspects-4.1.6.RELEASE

• spring-beans-4.1.6.RELEASE

• spring-context-4.1.6.RELEASE

• spring-context-support-4.1.6.RELEASE

• spring-core-4.1.6.RELEASE

• spring-expression-4.1.6.RELEASE

• spring-instrument-4.1.6.RELEASE

• spring-instrument-tomcat-4.1.6.RELEASE

• spring-jdbc-4.1.6.RELEASE

• spring-jms-4.1.6.RELEASE

• spring-messaging-4.1.6.RELEASE

• spring-orm-4.1.6.RELEASE

• spring-oxm-4.1.6.RELEASE

• spring-test-4.1.6.RELEASE

• spring-tx-4.1.6.RELEASE

• spring-web-4.1.6.RELEASE

• spring-webmvc-4.1.6.RELEASE

• spring-webmvc-portlet-4.1.6.RELEASE

• spring-websocket-4.1.6.RELEASE

Passaggio 3: creare file di origine

Ora creiamo i file sorgente effettivi sotto HelloSpringprogetto. Per prima cosa dobbiamo creare un pacchetto chiamatocom.tutorialspoint. Per fare ciò, fare clic con il pulsante destro del mouse susrc nella sezione Esplora pacchetti e segui l'opzione - New → Package.

Successivamente creeremo HelloWorld.java e MainApp.java file nel pacchetto com.tutorialspoint.

Ecco il contenuto di HelloWorld.java file -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del secondo file MainApp.java -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
   }
}

Di seguito due punti importanti da notare sul programma principale:

• Il primo passaggio consiste nel creare un contesto dell'applicazione in cui abbiamo utilizzato l'API del framework ClassPathXmlApplicationContext(). Questa API carica il file di configurazione dei bean e, eventualmente, in base all'API fornita, si occupa di creare e inizializzare tutti gli oggetti, cioè i bean citati nel file di configurazione.

• Il secondo passaggio viene utilizzato per ottenere il bean richiesto utilizzando getBean()metodo del contesto creato. Questo metodo utilizza l'ID bean per restituire un oggetto generico, che alla fine può essere sottoposto a cast all'oggetto effettivo. Una volta che hai un oggetto, puoi usare questo oggetto per chiamare qualsiasi metodo di classe.

Passaggio 4: creare il file di configurazione del bean

È necessario creare un file di configurazione Bean che è un file XML e funge da cemento che incolla i fagioli, cioè le classi insieme. Questo file deve essere creato sotto ilsrc directory come mostrato nello screenshot seguente -

Di solito gli sviluppatori chiamano questo file come Beans.xml, ma sei indipendente per scegliere il nome che preferisci. Devi assicurarti che questo file sia disponibile in CLASSPATH e utilizzare lo stesso nome nell'applicazione principale durante la creazione di un contesto dell'applicazione come mostrato nel file MainApp.java.

Beans.xml viene utilizzato per assegnare ID univoci a bean diversi e per controllare la creazione di oggetti con valori diversi senza influire su nessuno dei file sorgente di Spring. Ad esempio, utilizzando il seguente file è possibile passare qualsiasi valore per la variabile "messaggio" e stampare diversi valori del messaggio senza influire sui file HelloWorld.java e MainApp.java. Vediamo come funziona -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Quando l'applicazione Spring viene caricata in memoria, Framework utilizza il file di configurazione di cui sopra per creare tutti i bean definiti e assegna loro un ID univoco come definito in <bean>etichetta. Puoi usare<property> tag per passare i valori di diverse variabili utilizzate al momento della creazione dell'oggetto.

Passaggio 5: esecuzione del programma

Una volta terminata la creazione dei file di configurazione dei sorgenti e dei bean, si è pronti per questo passaggio, ovvero la compilazione e l'esecuzione del programma. Per fare ciò, mantieni attiva la scheda del file MainApp.Java e usa entrambiRun opzione disponibile nell'IDE Eclipse o utilizzare Ctrl + F11 per compilare ed eseguire il tuo MainAppapplicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio nella console dell'IDE di Eclipse:

Your Message : Hello World!

Congratulazioni, hai creato con successo la tua prima applicazione Spring. È possibile vedere la flessibilità della suddetta applicazione Spring modificando il valore della proprietà "message" e mantenendo invariati entrambi i file sorgente.

Il contenitore Spring è il fulcro di Spring Framework. Il contenitore creerà gli oggetti, li collegherà insieme, li configurerà e gestirà il loro ciclo di vita completo dalla creazione alla distruzione. Il contenitore Spring utilizza DI per gestire i componenti che compongono un'applicazione. Questi oggetti sono chiamati Spring Beans, di cui parleremo nel prossimo capitolo.

Il contenitore riceve le istruzioni su quali oggetti istanziare, configurare e assemblare leggendo i metadati di configurazione forniti. I metadati di configurazione possono essere rappresentati da XML, annotazioni Java o codice Java. Il diagramma seguente rappresenta una visione di alto livello di come funziona Spring. Il contenitore Spring IoC utilizza classi POJO Java e metadati di configurazione per produrre un sistema o un'applicazione completamente configurati ed eseguibili.

Spring fornisce i seguenti due distinti tipi di contenitori.

Sr.No.	Contenitore e descrizione
1	Contenitore Spring BeanFactory Questo è il contenitore più semplice che fornisce il supporto di base per DI ed è definito dall'interfaccia org.springframework.beans.factory.BeanFactory . BeanFactory e le interfacce correlate, come BeanFactoryAware, InitializingBean, DisposableBean, sono ancora presenti in Spring ai fini della compatibilità con le versioni precedenti di un gran numero di framework di terze parti che si integrano con Spring.
2	Contenitore Spring ApplicationContext Questo contenitore aggiunge funzionalità più specifiche dell'organizzazione come la capacità di risolvere messaggi di testo da un file delle proprietà e la possibilità di pubblicare eventi dell'applicazione su listener di eventi interessati. Questo contenitore è definito dall'interfaccia org.springframework.context.ApplicationContext .

Il contenitore ApplicationContext include tutte le funzionalità del contenitore BeanFactory , quindi è generalmente consigliato rispetto a BeanFactory . BeanFactory può ancora essere utilizzato per applicazioni leggere come dispositivi mobili o applicazioni basate su applet in cui il volume e la velocità dei dati sono significativi.

Vengono chiamati gli oggetti che costituiscono la spina dorsale dell'applicazione e che sono gestiti dal contenitore Spring IoC beans. Un bean è un oggetto che viene istanziato, assemblato e altrimenti gestito da un contenitore Spring IoC. Questi bean vengono creati con i metadati di configurazione forniti al contenitore. Ad esempio, sotto forma di definizioni XML <bean /> che hai già visto nei capitoli precedenti.

La definizione del fagiolo contiene le informazioni chiamate configuration metadata, necessario affinché il contenitore conosca quanto segue:

• Come creare un fagiolo
• Dettagli del ciclo di vita di Bean
• Le dipendenze di Bean

Tutti i metadati di configurazione di cui sopra si traducono in un insieme delle seguenti proprietà che costituiscono ciascuna definizione di bean.

Sr.No.	Proprietà e descrizione
1	class Questo attributo è obbligatorio e specifica la classe bean da utilizzare per creare il bean.
2	name Questo attributo specifica l'identificatore del bean in modo univoco. Nei metadati di configurazione basati su XML, si utilizzano gli attributi id e / o name per specificare gli identificatori del bean.
3	scope Questo attributo specifica l'ambito degli oggetti creati da una particolare definizione di bean e verrà discusso nel capitolo sugli ambiti dei bean.
4	constructor-arg Questo è usato per iniettare le dipendenze e sarà discusso nei capitoli successivi.
5	properties Questo è usato per iniettare le dipendenze e sarà discusso nei capitoli successivi.
6	autowiring mode Questo è usato per iniettare le dipendenze e sarà discusso nei capitoli successivi.
7	lazy-initialization mode Un bean inizializzato in modo pigro indica al contenitore IoC di creare un'istanza di bean quando viene richiesto per la prima volta, piuttosto che all'avvio.
8	initialization method Un callback da chiamare subito dopo che tutte le proprietà necessarie sul bean sono state impostate dal contenitore. Sarà discusso nel capitolo sul ciclo di vita del fagiolo.
9	destruction method Un callback da utilizzare quando il contenitore contenente il bean viene distrutto. Sarà discusso nel capitolo sul ciclo di vita del fagiolo.

Metadati di configurazione Spring

Il contenitore Spring IoC è totalmente disaccoppiato dal formato in cui questi metadati di configurazione sono effettivamente scritti. Di seguito sono riportati i tre metodi importanti per fornire metadati di configurazione allo Spring Container:

• File di configurazione basato su XML.
• Configurazione basata su annotazioni
• Configurazione basata su Java

Hai già visto come i metadati di configurazione basati su XML vengono forniti al contenitore, ma vediamo un altro esempio di file di configurazione basato su XML con definizioni di bean diverse tra cui inizializzazione pigra, metodo di inizializzazione e metodo di distruzione -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- A simple bean definition -->
   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with lazy init set on -->
   <bean id = "..." class = "..." lazy-init = "true">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with initialization method -->
   <bean id = "..." class = "..." init-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with destruction method -->
   <bean id = "..." class = "..." destroy-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- more bean definitions go here -->
   
</beans>

Puoi controllare Spring Hello World Example per capire come definire, configurare e creare Spring Beans.

Discuteremo della configurazione basata sull'annotazione in un capitolo separato. Viene discusso intenzionalmente in un capitolo separato poiché vogliamo che tu cogli alcuni altri importanti concetti di Spring, prima di iniziare a programmare con Spring Dependency Injection with Annotations.

Quando si definisce un <bean> si ha la possibilità di dichiarare uno scope per quel bean. Ad esempio, per forzare Spring a produrre una nuova istanza di bean ogni volta che ne è necessaria una, è necessario dichiarare l'attributo scope del bean comeprototype. Allo stesso modo, se vuoi che Spring restituisca la stessa istanza del bean ogni volta che ne è necessaria una, devi dichiarare che l'attributo scope del bean siasingleton.

Spring Framework supporta i seguenti cinque ambiti, tre dei quali sono disponibili solo se si utilizza un ApplicationContext compatibile con il Web.

Sr.No.	Ambito e descrizione
1	singleton Questo ambito della definizione del bean a una singola istanza per contenitore Spring IoC (impostazione predefinita).
2	prototype Ciò consente a una singola definizione di bean di avere un numero qualsiasi di istanze di oggetto.
3	request Questo ambito da una definizione di bean a una richiesta HTTP. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.
4	session Questo ambito da una definizione di bean a una sessione HTTP. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.
5	global-session Questo ambito da una definizione di bean a una sessione HTTP globale. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.

In questo capitolo, discuteremo dei primi due ambiti e gli altri tre verranno discussi quando discuteremo di Spring ApplicationContext compatibile con il web.

L'ambito singleton

Se un ambito è impostato su singleton, il contenitore Spring IoC crea esattamente un'istanza dell'oggetto definito da quella definizione di bean. Questa singola istanza viene archiviata in una cache di tali bean singleton e tutte le richieste e i riferimenti successivi per quel bean denominato restituiscono l'oggetto memorizzato nella cache.

L'ambito predefinito è sempre singleton. Tuttavia, quando è necessaria una e una sola istanza di un bean, è possibile impostare l'estensionescope proprietà a singleton nel file di configurazione del bean, come mostrato nel seguente frammento di codice:

<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
   <!-- collaborators and configuration for this bean go here -->
</bean>

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del file MainApp.java file -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

      objA.setMessage("I'm object A");
      objA.getMessage();

      HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
      objB.getMessage();
   }
}

Di seguito è riportato il file di configurazione Beans.xml richiesto per l'ambito singleton -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "singleton">
   </bean>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Your Message : I'm object A
Your Message : I'm object A

Lo scopo del prototipo

Se l'ambito è impostato su prototipo, il contenitore Spring IoC crea una nuova istanza di bean dell'oggetto ogni volta che viene effettuata una richiesta per quel bean specifico. Di norma, utilizzare l'ambito del prototipo per tutti i bean con stato completo e l'ambito singleton per i bean senza stato.

Per definire un ambito del prototipo, è possibile impostare il scope proprietà a prototype nel file di configurazione del bean, come mostrato nel seguente frammento di codice:

<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
   <!-- collaborators and configuration for this bean go here -->
</bean>

Esempio

Cerchiamo di avere l'IDE Eclipse funzionante e seguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del file MainApp.java file -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

      objA.setMessage("I'm object A");
      objA.getMessage();

      HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
      objB.getMessage();
   }
}

Di seguito è riportato il file di configurazione Beans.xml richiesto per l'ambito del prototipo -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "prototype">
   </bean>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Your Message : I'm object A
Your Message : null

Il ciclo di vita di un fagiolo primaverile è facile da capire. Quando viene creata un'istanza di un bean, potrebbe essere necessario eseguire alcune inizializzazioni per portarlo in uno stato utilizzabile. Allo stesso modo, quando il fagiolo non è più necessario e viene rimosso dal contenitore, potrebbe essere necessaria una pulizia.

Sebbene ci siano elenchi delle attività che si svolgono dietro le quinte tra il momento dell'istanziazione del bean e la sua distruzione, questo capitolo discuterà solo due importanti metodi di callback del ciclo di vita del bean, che sono richiesti al momento dell'inizializzazione del bean e della sua distruzione.

Per definire il setup e lo smontaggio di un bean, dichiariamo semplicemente <bean> con initmethod e / o destroy-methodparametri. L'attributo init-method specifica un metodo che deve essere chiamato sul bean immediatamente dopo l'istanza. Allo stesso modo, destroymethod specifica un metodo che viene chiamato appena prima che un bean venga rimosso dal contenitore.

Callback di inizializzazione

L'interfaccia org.springframework.beans.factory.InitializingBean specifica un unico metodo:

void afterPropertiesSet() throws Exception;

Pertanto, puoi semplicemente implementare l'interfaccia sopra e il lavoro di inizializzazione può essere fatto all'interno del metodo afterPropertiesSet () come segue:

public class ExampleBean implements InitializingBean {
   public void afterPropertiesSet() {
      // do some initialization work
   }
}

Nel caso di metadati di configurazione basati su XML, è possibile utilizzare l'estensione init-methodattributo per specificare il nome del metodo che ha una firma vuota senza argomenti. Ad esempio:

<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>

Di seguito è riportata la definizione della classe:

public class ExampleBean {
   public void init() {
      // do some initialization work
   }
}

Richiami di distruzione

L' interfaccia org.springframework.beans.factory.DisposableBean specifica un unico metodo:

void destroy() throws Exception;

Quindi, puoi semplicemente implementare l'interfaccia sopra e il lavoro di finalizzazione può essere fatto all'interno del metodo destroy () come segue:

public class ExampleBean implements DisposableBean {
   public void destroy() {
      // do some destruction work
   }
}

Nel caso di metadati di configurazione basati su XML, è possibile utilizzare l'estensione destroy-methodattributo per specificare il nome del metodo che ha una firma vuota senza argomenti. Ad esempio:

<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>

Di seguito è riportata la definizione della classe:

public class ExampleBean {
   public void destroy() {
      // do some destruction work
   }
}

Se utilizzi il contenitore IoC di Spring in un ambiente di applicazioni non Web; ad esempio, in un ambiente desktop rich client, si registra un hook di arresto con JVM. In questo modo si garantisce un arresto regolare e si richiamano i metodi di distruzione pertinenti sui bean singleton in modo che tutte le risorse vengano rilasciate.

Si consiglia di non utilizzare i callback InitializingBean o DisposableBean, poiché la configurazione XML offre molta flessibilità in termini di denominazione del metodo.

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy() {
      System.out.println("Bean will destroy now.");
   }
}

Di seguito è riportato il contenuto del file MainApp.javafile. Qui è necessario registrare un hook di spegnimentoregisterShutdownHook()metodo dichiarato nella classe AbstractApplicationContext. Ciò garantirà un arresto regolare e chiamerà i metodi di distruzione pertinenti.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

Di seguito è riportato il file di configurazione Beans.xml richiesto per i metodi di inizializzazione e distruzione -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" init-method = "init" 
      destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Bean is going through init.
Your Message : Hello World!
Bean will destroy now.

Metodi di inizializzazione e distruzione predefiniti

Se hai troppi bean con metodi di inizializzazione e / o di distruzione con lo stesso nome, non è necessario dichiararli init-method e destroy-methodsu ogni singolo chicco. Invece, il framework fornisce la flessibilità per configurare tale situazione utilizzandodefault-init-method e default-destroy-method attributi sull'elemento <beans> come segue:

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
   default-init-method = "init" 
   default-destroy-method = "destroy">

   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   
</beans>

Il BeanPostProcessor l'interfaccia definisce i metodi di callback che è possibile implementare per fornire la propria logica di istanziazione, logica di risoluzione delle dipendenze, ecc. È anche possibile implementare una logica personalizzata dopo che il contenitore Spring ha terminato di istanziare, configurare e inizializzare un bean collegando una o più implementazioni BeanPostProcessor .

È possibile configurare più interfacce BeanPostProcessor e controllare l'ordine in cui vengono eseguite queste interfacce BeanPostProcessor impostando order purché BeanPostProcessor implementi la proprietà Ordered interfaccia.

I BeanPostProcessor operano su istanze di bean (o oggetto), il che significa che il contenitore Spring IoC crea un'istanza di bean e quindi le interfacce BeanPostProcessor fanno il loro lavoro.

Un ApplicationContext rileva automaticamente tutti i bean definiti con l'implementazione di BeanPostProcessor e registra questi bean come postprocessori, per essere poi richiamati in modo appropriato dal contenitore al momento della creazione del bean.

Esempio

Gli esempi seguenti mostrano come scrivere, registrare e utilizzare BeanPostProcessors nel contesto di un ApplicationContext.

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld , InitHelloWorld e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

Questo è un esempio molto semplice di implementazione di BeanPostProcessor, che stampa un nome di bean prima e dopo l'inizializzazione di qualsiasi bean. È possibile implementare una logica più complessa prima e dopo l'inizializzazione di un bean perché si ha accesso all'oggetto bean all'interno di entrambi i metodi del post processore.

Ecco il contenuto di InitHelloWorld.java file -

package com.tutorialspoint;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

Di seguito è riportato il contenuto del file MainApp.javafile. Qui è necessario registrare un hook di spegnimentoregisterShutdownHook()metodo dichiarato nella classe AbstractApplicationContext. Ciò garantirà un arresto regolare e chiamerà i metodi di distruzione pertinenti.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

Di seguito è riportato il file di configurazione Beans.xml richiesto per i metodi di inizializzazione e distruzione -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean class = "com.tutorialspoint.InitHelloWorld" />

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.

Una definizione di bean può contenere molte informazioni di configurazione, inclusi argomenti del costruttore, valori di proprietà e informazioni specifiche del contenitore come il metodo di inizializzazione, il nome del metodo factory statico e così via.

Una definizione di bean figlio eredita i dati di configurazione da una definizione padre. La definizione figlio può sovrascrivere alcuni valori o aggiungerne altri, se necessario.

L'ereditarietà della definizione Spring Bean non ha nulla a che fare con l'ereditarietà della classe Java, ma il concetto di ereditarietà è lo stesso. È possibile definire una definizione di bean padre come modello e altri bean figlio possono ereditare la configurazione richiesta dal bean padre.

Quando si utilizzano metadati di configurazione basati su XML, si indica una definizione di bean figlio utilizzando il parent attributo, specificando il bean genitore come valore di questo attributo.

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld , HelloIndia e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Di seguito è riportato il file di configurazione Beans.xmldove abbiamo definito il bean "helloWorld" che ha due proprietà message1 e message2 . Il successivo bean "helloIndia" è stato definito come figlio del bean "helloWorld" utilizzandoparentattributo. Il bean figlio eredita la proprietà message2 così com'è, sovrascrive la proprietà message1 e introduce un'altra proprietà message3 .

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
   </bean>

   <bean id ="helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
</beans>

Ecco il contenuto di HelloWorld.java file -

package com.tutorialspoint;

public class HelloWorld {
   private String message1;
   private String message2;

   public void setMessage1(String message){
      this.message1 = message;
   }
   public void setMessage2(String message){
      this.message2 = message;
   }
   public void getMessage1(){
      System.out.println("World Message1 : " + message1);
   }
   public void getMessage2(){
      System.out.println("World Message2 : " + message2);
   }
}

Ecco il contenuto di HelloIndia.java file -

package com.tutorialspoint;

public class HelloIndia {
   private String message1;
   private String message2;
   private String message3;

   public void setMessage1(String message){
      this.message1 = message;
   }
   public void setMessage2(String message){
      this.message2 = message;
   }
   public void setMessage3(String message){
      this.message3 = message;
   }
   public void getMessage1(){
      System.out.println("India Message1 : " + message1);
   }
   public void getMessage2(){
      System.out.println("India Message2 : " + message2);
   }
   public void getMessage3(){
      System.out.println("India Message3 : " + message3);
   }
}

Di seguito è riportato il contenuto del file MainApp.java file -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      
      HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
      objA.getMessage1();
      objA.getMessage2();

      HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
      objB.getMessage1();
      objB.getMessage2();
      objB.getMessage3();
   }
}

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!

Se hai osservato qui, non abbiamo passato message2 durante la creazione del bean "helloIndia", ma è stato passato a causa dell'ereditarietà della definizione del bean.

Modello di definizione del fagiolo

È possibile creare un modello di definizione Bean, che può essere utilizzato da altre definizioni di bean figlio senza impegnarsi molto. Durante la definizione di un modello di definizione bean, non è necessario specificare il fileclass attributo e dovrebbe specificare abstract attributo e dovrebbe specificare l'attributo abstract con un valore di true come mostrato nello snippet di codice seguente:

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "beanTeamplate" abstract = "true">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>

   <bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
   
</beans>

Il bean genitore non può essere istanziato da solo perché è incompleto ed è anche esplicitamente contrassegnato come astratto . Quando una definizione è astratta come questa, è utilizzabile solo come definizione di bean modello puro che funge da definizione padre per le definizioni figlio.

Ogni applicazione basata su Java ha alcuni oggetti che lavorano insieme per presentare ciò che l'utente finale vede come un'applicazione funzionante. Quando si scrive un'applicazione Java complessa, le classi dell'applicazione dovrebbero essere il più indipendenti possibile da altre classi Java per aumentare la possibilità di riutilizzare queste classi e per testarle indipendentemente da altre classi durante il test unitario. Dependency Injection (o talvolta chiamato cablaggio) aiuta a incollare queste classi insieme e allo stesso tempo a mantenerle indipendenti.

Considera di avere un'applicazione che ha un componente di editor di testo e di voler fornire un controllo ortografico. Il tuo codice standard sarebbe simile a questo -

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

Quello che abbiamo fatto qui è creare una dipendenza tra TextEditor e SpellChecker. In uno scenario di inversione del controllo, faremmo invece qualcosa del genere:

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
}

Qui, TextEditor non dovrebbe preoccuparsi dell'implementazione del correttore ortografico. Il correttore ortografico verrà implementato in modo indipendente e verrà fornito a TextEditor al momento della creazione di istanze di TextEditor. L'intera procedura è controllata da Spring Framework.

Qui, abbiamo rimosso il controllo totale da TextEditor e lo abbiamo mantenuto altrove (cioè file di configurazione XML) e la dipendenza (cioè la classe SpellChecker) viene iniettata nella classe TextEditor attraverso un Class Constructor. Così il flusso di controllo è stato "invertito" da Dependency Injection (DI) perché hai effettivamente delegato le dipendenze a qualche sistema esterno.

Il secondo metodo per iniettare dipendenza è attraverso Setter Methodsdella classe TextEditor in cui creeremo un'istanza SpellChecker. Questa istanza verrà utilizzata per chiamare i metodi setter per inizializzare le proprietà di TextEditor.

Pertanto, DI esiste in due varianti principali ei seguenti due sottocapitoli copriranno entrambi con esempi:

Sr.No.	Tipo di inserimento delle dipendenze e descrizione
1	Inserimento delle dipendenze basato sul costruttore La DI basata sul costruttore viene eseguita quando il contenitore richiama un costruttore di classe con un numero di argomenti, ciascuno dei quali rappresenta una dipendenza dall'altra classe.
2	Inserimento delle dipendenze basato su setter La DI basata su setter viene eseguita dal contenitore che chiama i metodi setter sui tuoi bean dopo aver richiamato un costruttore senza argomenti o un metodo factory statico senza argomenti per istanziare il tuo bean.

È possibile combinare DI sia basato su costruttore che basato su Setter, ma è una buona regola pratica utilizzare argomenti del costruttore per le dipendenze obbligatorie e setter per le dipendenze opzionali.

Il codice è più pulito con il principio DI e il disaccoppiamento è più efficace quando gli oggetti vengono forniti con le loro dipendenze. L'oggetto non cerca le sue dipendenze e non conosce l'ubicazione o la classe delle dipendenze, anzi tutto è curato dallo Spring Framework.

Come sai le classi interne di Java sono definite nell'ambito di altre classi, allo stesso modo, inner beanssono bean definiti nell'ambito di un altro bean. Pertanto, un elemento <bean /> all'interno degli elementi <property /> o <constructor-arg /> è chiamato bean interno ed è mostrato di seguito.

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "outerBean" class = "...">
      <property name = "target">
         <bean id = "innerBean" class = "..."/>
      </property>
   </bean>

</beans>

Esempio

Cerchiamo di avere l'IDE Eclipse funzionante e seguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java TextEditor , SpellChecker e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di TextEditor.java file -

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;
   
   // a setter method to inject the dependency.
   public void setSpellChecker(SpellChecker spellChecker) {
      System.out.println("Inside setSpellChecker." );
      this.spellChecker = spellChecker;
   }
   
   // a getter method to return spellChecker
   public SpellChecker getSpellChecker() {
      return spellChecker;
   }
   public void spellCheck() {
      spellChecker.checkSpelling();
   }
}

Di seguito è riportato il contenuto di un altro file di classe dipendente SpellChecker.java -

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

Di seguito è riportato il contenuto del file MainApp.java file -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

Di seguito è riportato il file di configurazione Beans.xml che ha la configurazione per l'iniezione basata su setter ma usando inner beans -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for textEditor bean using inner bean -->
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
      <property name = "spellChecker">
         <bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
      </property>
   </bean>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.

Hai visto come configurare il tipo di dati primitivo usando value riferimenti ad attributi e oggetti utilizzando refattributo del tag <property> nel file di configurazione Bean. Entrambi i casi riguardano il passaggio di un valore singolare a un bean.

Ora cosa succede se si desidera passare valori plurali come i tipi di raccolta Java come List, Set, Map e Properties. Per gestire la situazione, Spring offre quattro tipi di elementi di configurazione della raccolta che sono i seguenti:

Suor n	Elemento e descrizione
1	<list> Questo aiuta nel cablaggio, cioè iniettando un elenco di valori, consentendo duplicati.
2	<set> Questo aiuta nel cablaggio di un insieme di valori ma senza duplicati.
3	<map> Questo può essere utilizzato per iniettare una raccolta di coppie nome-valore in cui nome e valore possono essere di qualsiasi tipo.
4	<props> Questo può essere usato per inserire una raccolta di coppie nome-valore in cui il nome e il valore sono entrambi stringhe.

È possibile utilizzare <list> o <set> per collegare qualsiasi implementazione di java.util.Collection o un file array.

Ti imbatterai in due situazioni (a) Passaggio di valori diretti della raccolta e (b) Passaggio di un riferimento di un bean come uno degli elementi della raccolta.

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java JavaCollection e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di JavaCollection.java file -

package com.tutorialspoint;
import java.util.*;

public class JavaCollection {
   List addressList;
   Set  addressSet;
   Map  addressMap;
   Properties addressProp;

   // a setter method to set List
   public void setAddressList(List addressList) {
      this.addressList = addressList;
   }
   
   // prints and returns all the elements of the list.
   public List getAddressList() {
      System.out.println("List Elements :"  + addressList);
      return addressList;
   }
   
   // a setter method to set Set
   public void setAddressSet(Set addressSet) {
      this.addressSet = addressSet;
   }
   
   // prints and returns all the elements of the Set.
   public Set getAddressSet() {
      System.out.println("Set Elements :"  + addressSet);
      return addressSet;
   }
   
   // a setter method to set Map
   public void setAddressMap(Map addressMap) {
      this.addressMap = addressMap;
   }
   
   // prints and returns all the elements of the Map.
   public Map getAddressMap() {
      System.out.println("Map Elements :"  + addressMap);
      return addressMap;
   }
   
   // a setter method to set Property
   public void setAddressProp(Properties addressProp) {
      this.addressProp = addressProp;
   }
   
   // prints and returns all the elements of the Property.
   public Properties getAddressProp() {
      System.out.println("Property Elements :"  + addressProp);
      return addressProp;
   }
}

Di seguito è riportato il contenuto del file MainApp.java file -

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      JavaCollection jc=(JavaCollection)context.getBean("javaCollection");

      jc.getAddressList();
      jc.getAddressSet();
      jc.getAddressMap();
      jc.getAddressProp();
   }
}

Di seguito è riportato il file di configurazione Beans.xml che ha la configurazione per tutti i tipi di collezioni -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for javaCollection -->
   <bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
      
      <!-- results in a setAddressList(java.util.List) call -->
      <property name = "addressList">
         <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </list>
      </property>

      <!-- results in a setAddressSet(java.util.Set) call -->
      <property name = "addressSet">
         <set>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </set>
      </property>

      <!-- results in a setAddressMap(java.util.Map) call -->
      <property name = "addressMap">
         <map>
            <entry key = "1" value = "INDIA"/>
            <entry key = "2" value = "Pakistan"/>
            <entry key = "3" value = "USA"/>
            <entry key = "4" value = "USA"/>
         </map>
      </property>
      
      <!-- results in a setAddressProp(java.util.Properties) call -->
      <property name = "addressProp">
         <props>
            <prop key = "one">INDIA</prop>
            <prop key = "one">INDIA</prop>
            <prop key = "two">Pakistan</prop>
            <prop key = "three">USA</prop>
            <prop key = "four">USA</prop>
         </props>
      </property>
   </bean>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

List Elements :[INDIA, Pakistan, USA, USA] 
Set Elements :[INDIA, Pakistan, USA] 
ap Elements :{1 = INDIA, 2 = Pakistan, 3 = USA, 4 = USA} 
Property Elements :{two = Pakistan, one = INDIA, three = USA, four = USA}

Riferimenti per l'iniezione di fagioli

La seguente definizione di Bean ti aiuterà a capire come inserire i riferimenti ai bean come uno degli elementi della raccolta. Anche tu puoi mescolare riferimenti e valori tutti insieme come mostrato nel seguente frammento di codice:

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Bean Definition to handle references and values -->
   <bean id = "..." class = "...">

      <!-- Passing bean reference  for java.util.List -->
      <property name = "addressList">
         <list>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </list>
      </property>
      
      <!-- Passing bean reference  for java.util.Set -->
      <property name = "addressSet">
         <set>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </set>
      </property>
      
      <!-- Passing bean reference  for java.util.Map -->
      <property name = "addressMap">
         <map>
            <entry key = "one" value = "INDIA"/>
            <entry key = "two" value-ref = "address1"/>
            <entry key = "three" value-ref = "address2"/>
         </map>
      </property>
   </bean>

</beans>

Per utilizzare la definizione di bean di cui sopra, è necessario definire i metodi setter in modo tale che siano in grado di gestire anche i riferimenti.

Inserimento di valori di stringa nulli e vuoti

Se devi passare una stringa vuota come valore, puoi passarla come segue:

<bean id = "..." class = "exampleBean">
   <property name = "email" value = ""/>
</bean>

L'esempio precedente è equivalente al codice Java: exampleBean.setEmail ("")

Se devi passare un valore NULL, puoi passarlo come segue:

<bean id = "..." class = "exampleBean">
   <property name = "email"><null/></property>
</bean>

L'esempio precedente è equivalente al codice Java: exampleBean.setEmail (null)

Hai imparato a dichiarare i bean usando l'elemento <bean> e iniettare <bean> usando gli elementi <constructor-arg> e <property> nel file di configurazione XML.

Il contenitore Spring può autowire relazioni tra i bean che collaborano senza utilizzare gli elementi <constructor-arg> e <property>, il che aiuta a ridurre la quantità di configurazione XML che scrivi per una grande applicazione basata su Spring.

Modalità di cablaggio automatico

Di seguito sono riportate le modalità di autowiring, che possono essere utilizzate per indicare al contenitore Spring di utilizzare l'autowiring per l'inserimento delle dipendenze. Si utilizza l'attributo autowire dell'elemento <bean /> per specificareautowire modalità per una definizione di bean.

Suor n	Modalità e descrizione
1	no Questa è l'impostazione predefinita che significa nessun cablaggio automatico e dovresti usare un riferimento esplicito al bean per il cablaggio. Non hai niente da fare di speciale per questo cablaggio. Questo è ciò che hai già visto nel capitolo Dependency Injection.
2	per nome Autowiring per nome proprietà. Il contenitore Spring esamina le proprietà dei bean su cui l' attributo autowire è impostato su byName nel file di configurazione XML. Quindi cerca di abbinare e collegare le sue proprietà con i bean definiti con gli stessi nomi nel file di configurazione.
3	byType Autowiring per tipo di dati della proprietà. Il contenitore Spring esamina le proprietà dei bean su cui l' attributo autowire è impostato su byType nel file di configurazione XML. Quindi cerca di abbinare e collegare una proprietà se ètypecorrisponde esattamente a uno dei nomi dei bean nel file di configurazione. Se esiste più di uno di questi bean, viene generata un'eccezione irreversibile.
4	constructor Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.
5	autodetect Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType.

You can use byType or constructor autowiring mode to wire arrays and other typed-collections.

Limitations with autowiring

Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing for developers to use it to wire only one or two bean definitions. Though, autowiring can significantly reduce the need to specify properties or constructor arguments but you should consider the limitations and disadvantages of autowiring before using them.

Sr.No.	Limitations & Description
1	Overriding possibility You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring.
2	Primitive data types You cannot autowire so-called simple properties such as primitives, Strings, and Classes.
3	Confusing nature Autowiring is less exact than explicit wiring, so if possible prefer using explict wiring.

Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.

Annotation injection is performed before XML injection. Thus, the latter configuration will override the former for properties wired through both approaches.

Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider the following configuration file in case you want to use any annotation in your Spring application.

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>
   <!-- bean definitions go here -->

</beans>

Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us look at a few important annotations to understand how they work −

Sr.No.	Annotation & Description
1	@Required The @Required annotation applies to bean property setter methods.
2	@Autowired The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties.
3	@Qualifier The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired.
4	JSR-250 Annotations Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations.

So far you have seen how we configure Spring beans using XML configuration file. If you are comfortable with XML configuration, then it is really not required to learn how to proceed with Java-based configuration as you are going to achieve the same result using either of the configurations available.

Java-based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations explained in this chapter.

@Configuration & @Bean Annotations

Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows −

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

The above code will be equivalent to the following XML configuration −

<beans>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>

Here, the method name is annotated with @Bean works as bean ID and it creates and returns the actual bean. Your configuration class can have a declaration for more than one @Bean. Once your configuration classes are defined, you can load and provide them to Spring container using AnnotationConfigApplicationContext as follows −

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

You can load various configuration classes as follows −

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();

   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

Example

Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −

Steps	Description
1	Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project.
2	Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.
3	Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org.
4	Create Java classes HelloWorldConfig, HelloWorld and MainApp under the com.tutorialspoint package.
5	The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

Here is the content of HelloWorldConfig.java file

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

Here is the content of HelloWorld.java file

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Following is the content of the MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
      HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
      helloWorld.setMessage("Hello World!");
      helloWorld.getMessage();
   }
}

Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −

Your Message : Hello World!

Injecting Bean Dependencies

When @Beans have dependencies on one another, expressing that the dependency is as simple as having one bean method calling another as follows −

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
   @Bean
   public Foo foo() {
      return new Foo(bar());
   }
   @Bean
   public Bar bar() {
      return new Bar();
   }
}

Here, the foo bean receives a reference to bar via the constructor injection. Now let us look at another working example.

Example

Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −

Steps	Description
1	Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project.
2	Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.
3	Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org.
4	Create Java classes TextEditorConfig, TextEditor, SpellChecker and MainApp under the com.tutorialspoint package.
5	The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

Here is the content of TextEditorConfig.java file

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class TextEditorConfig {
   @Bean 
   public TextEditor textEditor(){
      return new TextEditor( spellChecker() );
   }

   @Bean 
   public SpellChecker spellChecker(){
      return new SpellChecker( );
   }
}

Here is the content of TextEditor.java file

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;

   public TextEditor(SpellChecker spellChecker){
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

Following is the content of another dependent class file SpellChecker.java

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

Following is the content of the MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(TextEditorConfig.class);

      TextEditor te = ctx.getBean(TextEditor.class);
      te.spellCheck();
   }
}

Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

The @Import Annotation

The @Import annotation allows for loading @Bean definitions from another configuration class. Consider a ConfigA class as follows −

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

You can import above Bean declaration in another Bean Declaration as follows −

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B b() {
      return new B(); 
   }
}

Now, rather than needing to specify both ConfigA.class and ConfigB.class when instantiating the context, only ConfigB needs to be supplied as follows −

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
   
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

Callback del ciclo di vita

L'annotazione @Bean supporta la specifica di metodi di callback di inizializzazione e distruzione arbitrari, proprio come gli attributi init-method e destroy-method di Spring XML sull'elemento bean -

public class Foo {
   public void init() {
      // initialization logic
   }
   public void cleanup() {
      // destruction logic
   }
}
@Configuration
public class AppConfig {
   @Bean(initMethod = "init", destroyMethod = "cleanup" )
   public Foo foo() {
      return new Foo();
   }
}

Specifica dell'ambito del bean

L'ambito predefinito è singleton, ma puoi sovrascriverlo con l'annotazione @Scope come segue:

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}

Hai visto in tutti i capitoli che il cuore della primavera è il ApplicationContext, che gestisce l'intero ciclo di vita dei chicchi. ApplicationContext pubblica determinati tipi di eventi durante il caricamento dei bean. Ad esempio, un ContextStartedEvent viene pubblicato quando il contesto viene avviato e ContextStoppedEvent viene pubblicato quando il contesto viene interrotto.

La gestione in caso ApplicationContext è fornita attraverso l'ApplicationEvent di classe e ApplicationListener interfaccia. Quindi, se un bean implementa ApplicationListener , ogni volta che un ApplicationEvent viene pubblicato in ApplicationContext, quel bean riceve una notifica.

La primavera offre i seguenti eventi standard:

Sr.No.	Eventi e descrizione incorporati di primavera
1	ContextRefreshedEvent Questo evento viene pubblicato quando ApplicationContext viene inizializzato o aggiornato. Questo può anche essere generato utilizzando il metodo refresh () sull'interfaccia ConfigurableApplicationContext .
2	ContextStartedEvent Questo evento viene pubblicato quando ApplicationContext viene avviato utilizzando il metodo start () sull'interfaccia ConfigurableApplicationContext . È possibile eseguire il polling del database o riavviare qualsiasi applicazione arrestata dopo aver ricevuto questo evento.
3	ContextStoppedEvent Questo evento viene pubblicato quando ApplicationContext viene arrestato utilizzando il metodo stop () sull'interfaccia ConfigurableApplicationContext . Dopo aver ricevuto questo evento, puoi svolgere il lavoro di pulizia richiesto.
4	ContextClosedEvent Questo evento viene pubblicato quando ApplicationContext viene chiuso utilizzando il metodo close () sull'interfaccia ConfigurableApplicationContext . Un contesto chiuso raggiunge la sua fine della vita; non può essere aggiornato o riavviato.
5	RequestHandledEvent Questo è un evento specifico per il web che dice a tutti i bean che una richiesta HTTP è stata soddisfatta.

La gestione degli eventi di Spring è a thread singolo, quindi se un evento viene pubblicato, fino a quando ea meno che tutti i destinatari non ricevano il messaggio, i processi vengono bloccati e il flusso non continuerà. Pertanto, è necessario prestare attenzione durante la progettazione dell'applicazione se è necessario utilizzare la gestione degli eventi.

Ascolto di eventi di contesto

Per ascoltare un evento di contesto, un bean dovrebbe implementare l' interfaccia ApplicationListener che ha un solo metodoonApplicationEvent(). Quindi scriviamo un esempio per vedere come si propagano gli eventi e come puoi inserire il tuo codice per eseguire l'attività richiesta in base a determinati eventi.

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passo	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld , CStartEventHandler , CStopEventHandler e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del file CStartEventHandler.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class CStartEventHandler 
   implements ApplicationListener<ContextStartedEvent>{

   public void onApplicationEvent(ContextStartedEvent event) {
      System.out.println("ContextStartedEvent Received");
   }
}

Di seguito è riportato il contenuto del file CStopEventHandler.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;

public class CStopEventHandler 
   implements ApplicationListener<ContextStoppedEvent>{

   public void onApplicationEvent(ContextStoppedEvent event) {
      System.out.println("ContextStoppedEvent Received");
   }
}

Di seguito è riportato il contenuto del file MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      // Let us raise a start event.
      context.start();
	  
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();

      // Let us raise a stop event.
      context.stop();
   }
}

Di seguito è riportato il file di configurazione Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
   <bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Received

Se lo desideri, puoi pubblicare i tuoi eventi personalizzati e successivamente puoi acquisire gli stessi per intraprendere qualsiasi azione contro quegli eventi personalizzati. Se sei interessato a scrivere i tuoi eventi personalizzati, puoi controllare Eventi personalizzati in primavera.

Esistono numerosi passaggi da eseguire per scrivere e pubblicare i propri eventi personalizzati. Segui le istruzioni fornite in questo capitolo per scrivere, pubblicare e gestire eventi primaverili personalizzati.

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrccartella nel progetto creato. Tutte le classi verranno create in questo pacchetto.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea una classe evento, CustomEvent estendendolaApplicationEvent. Questa classe deve definire un costruttore predefinito che dovrebbe ereditare il costruttore dalla classe ApplicationEvent.
4	Una volta definita la classe dell'evento, puoi pubblicarla da qualsiasi classe, diciamo EventClassPublisher che implementa ApplicationEventPublisherAware . Sarà inoltre necessario dichiarare questa classe nel file di configurazione XML come bean in modo che il contenitore possa identificare il bean come editore di eventi perché implementa l'interfaccia ApplicationEventPublisherAware.
5	Un evento pubblicato può essere gestito in una classe, diciamo EventClassHandler che implementa l' interfaccia ApplicationListener e implementa il metodo onApplicationEvent per l'evento personalizzato.
6	Crea il file di configurazione dei bean Beans.xml sottosrccartella e una classe MainApp che funzionerà come applicazione Spring.
7	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di CustomEvent.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent{
   public CustomEvent(Object source) {
      super(source);
   }
   public String toString(){
      return "My Custom Event";
   }
}

Di seguito è riportato il contenuto del file CustomEventPublisher.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

public class CustomEventPublisher implements ApplicationEventPublisherAware {
   private ApplicationEventPublisher publisher;
   
   public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
      this.publisher = publisher;
   }
   public void publish() {
      CustomEvent ce = new CustomEvent(this);
      publisher.publishEvent(ce);
   }
}

Di seguito è riportato il contenuto del file CustomEventHandler.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;

public class CustomEventHandler implements ApplicationListener<CustomEvent> {
   public void onApplicationEvent(CustomEvent event) {
      System.out.println(event.toString());
   }
}

Di seguito è riportato il contenuto del file MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");
	  
      CustomEventPublisher cvp = 
         (CustomEventPublisher) context.getBean("customEventPublisher");
      
      cvp.publish();  
      cvp.publish();
   }
}

Di seguito è riportato il file di configurazione Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
   <bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>

</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

y Custom Event
y Custom Event

Uno dei componenti chiave di Spring Framework è Aspect oriented programming (AOP)struttura. La programmazione orientata agli aspetti comporta la scomposizione della logica del programma in parti distinte chiamate cosiddette preoccupazioni. Vengono chiamate le funzioni che si estendono su più punti di un'applicazionecross-cutting concernse queste preoccupazioni trasversali sono concettualmente separate dalla logica di business dell'applicazione. Esistono vari buoni esempi comuni di aspetti come registrazione, verifica, transazioni dichiarative, sicurezza, memorizzazione nella cache, ecc.

L'unità chiave della modularità in OOP è la classe, mentre in AOP l'unità di modularità è l'aspetto. L'inserimento delle dipendenze ti aiuta a disaccoppiare gli oggetti dell'applicazione l'uno dall'altro e AOP ti aiuta a disaccoppiare i problemi di cross-cutting dagli oggetti che influenzano. AOP è come i trigger nei linguaggi di programmazione come Perl, .NET, Java e altri.

Il modulo Spring AOP fornisce intercettori per intercettare un'applicazione. Ad esempio, quando viene eseguito un metodo, è possibile aggiungere funzionalità extra prima o dopo l'esecuzione del metodo.

Terminologie AOP

Prima di iniziare a lavorare con AOP, familiarizziamo con i concetti e la terminologia AOP. Questi termini non sono specifici della primavera, piuttosto sono correlati alla AOP.

Suor n	Termini e descrizione
1	Aspect Questo è un modulo che ha una serie di API che forniscono requisiti trasversali. Ad esempio, un modulo di registrazione sarebbe chiamato aspetto AOP per la registrazione. Un'applicazione può avere un numero qualsiasi di aspetti a seconda del requisito.
2	Join point Questo rappresenta un punto nella tua applicazione in cui puoi inserire l'aspetto AOP. Puoi anche dire che è il punto effettivo dell'applicazione in cui verrà eseguita un'azione utilizzando il framework Spring AOP.
3	Advice Questa è l'azione effettiva da intraprendere prima o dopo l'esecuzione del metodo. Questo è un pezzo di codice effettivo che viene richiamato durante l'esecuzione del programma dal framework Spring AOP.
4	Pointcut Questo è un insieme di uno o più punti di unione in cui deve essere eseguito un consiglio. Puoi specificare i punti di taglio utilizzando espressioni o modelli come vedremo nei nostri esempi AOP.
5	Introduction Un'introduzione consente di aggiungere nuovi metodi o attributi alle classi esistenti.
6	Target object Oggetto consigliato da uno o più aspetti. Questo oggetto sarà sempre un oggetto proxy, denominato anche oggetto consigliato.
7	Weaving La tessitura è il processo di collegamento di aspetti con altri tipi di applicazioni o oggetti per creare un oggetto consigliato. Questa operazione può essere eseguita in fase di compilazione, caricamento o in fase di esecuzione.

Tipi di consigli

Gli aspetti primaverili possono funzionare con cinque tipi di consigli menzionati di seguito:

Suor n	Consigli e descrizione
1	before Esegui consigli prima dell'esecuzione del metodo a.
2	after Esegui un consiglio dopo l'esecuzione del metodo, indipendentemente dal suo risultato.
3	after-returning Eseguire il consiglio dopo l'esecuzione del metodo a solo se il metodo viene completato correttamente.
4	after-throwing Esegui il consiglio dopo l'esecuzione del metodo a solo se il metodo esce generando un'eccezione.
5	around Eseguire il consiglio prima e dopo che il metodo consigliato è stato richiamato.

Implementazione di aspetti personalizzati

La primavera sostiene il @AspectJ annotation style approccio e il schema-basedapproccio per implementare aspetti personalizzati. Questi due approcci sono stati spiegati in dettaglio nelle sezioni seguenti.

Suor n	Approccio e descrizione
1	Basato su XML Schema Gli aspetti vengono implementati utilizzando le classi regolari insieme alla configurazione basata su XML.
2	Basato su @AspectJ @AspectJ fa riferimento a uno stile di dichiarazione degli aspetti come normali classi Java annotate con annotazioni Java 5.

Mentre si lavora con il database utilizzando il semplice vecchio JDBC, diventa complicato scrivere codice non necessario per gestire le eccezioni, aprire e chiudere le connessioni al database, ecc. Tuttavia, Spring JDBC Framework si prende cura di tutti i dettagli di basso livello a partire dall'apertura della connessione, preparare ed eseguire l'istruzione SQL, elaborare le eccezioni, gestire le transazioni e infine chiudere la connessione.

Quindi quello che devi fare è solo definire i parametri di connessione e specificare l'istruzione SQL da eseguire e fare il lavoro richiesto per ogni iterazione durante il recupero dei dati dal database.

Spring JDBC fornisce diversi approcci e corrispondentemente classi differenti per interfacciarsi con il database. Prenderò l'approccio classico e più popolare che utilizzaJdbcTemplateclasse del framework. Questa è la classe del framework centrale che gestisce tutte le comunicazioni del database e la gestione delle eccezioni.

Classe JdbcTemplate

La classe Template JDBC esegue query SQL, aggiorna le istruzioni, memorizza le chiamate di procedura, esegue l'iterazione sui ResultSet ed estrae i valori dei parametri restituiti. Inoltre rileva le eccezioni JDBC e le traduce nella gerarchia delle eccezioni generica, più informativa, definita nel pacchetto org.springframework.dao.

Le istanze della JdbcTemplate classe sono threadsafe una volta configurato. Quindi puoi configurare una singola istanza di un JdbcTemplate e quindi inserire in modo sicuro questo riferimento condiviso in più DAO.

Una pratica comune quando si utilizza la classe JDBC Template consiste nel configurare un DataSource nel file di configurazione Spring, quindi inserire in dipendenza il bean DataSource condiviso nelle classi DAO e il JdbcTemplate viene creato nel setter per DataSource.

Configurazione dell'origine dati

Creiamo una tabella di database Student nel nostro database TEST. Presumiamo che tu stia lavorando con il database MySQL, se lavori con qualsiasi altro database, puoi modificare di conseguenza le tue query DDL e SQL.

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Ora dobbiamo fornire un DataSource al modello JDBC in modo che possa configurarsi per ottenere l'accesso al database. È possibile configurare DataSource nel file XML con una parte di codice come mostrato nel seguente frammento di codice:

<bean id = "dataSource" 
   class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
   <property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
   <property name = "username" value = "root"/>
   <property name = "password" value = "password"/>
</bean>

Oggetto di accesso ai dati (DAO)

DAO è l'acronimo di Data Access Object, comunemente utilizzato per l'interazione con il database. I DAO esistono per fornire un mezzo per leggere e scrivere dati nel database e dovrebbero esporre questa funzionalità attraverso un'interfaccia con cui il resto dell'applicazione accederà ad essi.

Il supporto DAO in Spring semplifica il lavoro con tecnologie di accesso ai dati come JDBC, Hibernate, JPA o JDO in modo coerente.

Esecuzione di istruzioni SQL

Vediamo come possiamo eseguire operazioni CRUD (Crea, Leggi, Aggiorna ed Elimina) sulle tabelle del database utilizzando SQL e l'oggetto Template JDBC.

Querying for an integer

String SQL = "select count(*) from Student";
int rowCount = jdbcTemplateObject.queryForInt( SQL );

Querying for a long

String SQL = "select count(*) from Student";
long rowCount = jdbcTemplateObject.queryForLong( SQL );

A simple query using a bind variable

String SQL = "select age from Student where id = ?";
int age = jdbcTemplateObject.queryForInt(SQL, new Object[]{10});

Querying for a String

String SQL = "select name from Student where id = ?";
String name = jdbcTemplateObject.queryForObject(SQL, new Object[]{10}, String.class);

Querying and returning an object

String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
   SQL, new Object[]{10}, new StudentMapper());

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setID(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      
      return student;
   }
}

Querying and returning multiple objects

String SQL = "select * from Student";
List<Student> students = jdbcTemplateObject.query(
   SQL, new StudentMapper());

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setID(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      
      return student;
   }
}

Inserting a row into the table

String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 11} );

Updating a row into the table

String SQL = "update Student set name = ? where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 10} );

Deleting a row from the table

String SQL = "delete Student where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{20} );

Esecuzione di istruzioni DDL

Puoi usare il file execute(..)metodo da jdbcTemplate per eseguire qualsiasi istruzione SQL o istruzione DDL. Di seguito è riportato un esempio per utilizzare l'istruzione CREATE per creare una tabella:

String SQL = "CREATE TABLE Student( " +
   "ID   INT NOT NULL AUTO_INCREMENT, " +
   "NAME VARCHAR(20) NOT NULL, " +
   "AGE  INT NOT NULL, " +
   "PRIMARY KEY (ID));"

jdbcTemplateObject.execute( SQL );

Esempi di framework JDBC Spring

Sulla base dei concetti di cui sopra, controlliamo alcuni esempi importanti che ti aiuteranno a comprendere l'utilizzo del framework JDBC in primavera -

Sr.No.	Esempio e descrizione
1	Esempio di Spring JDBC Questo esempio spiegherà come scrivere una semplice applicazione Spring basata su JDBC.
2	Procedura memorizzata SQL in primavera Scopri come chiamare la procedura memorizzata SQL durante l'utilizzo di JDBC in Spring.

Una transazione di database è una sequenza di azioni che vengono trattate come una singola unità di lavoro. Queste azioni dovrebbero essere completate completamente o non avere alcun effetto. La gestione delle transazioni è una parte importante dell'applicazione aziendale orientata a RDBMS per garantire l'integrità e la coerenza dei dati. Il concetto di transazione può essere descritto con le seguenti quattro proprietà chiave descritte comeACID -

• Atomicity - Una transazione dovrebbe essere trattata come una singola unità di operazione, il che significa che l'intera sequenza di operazioni ha esito positivo o negativo.

• Consistency - Questo rappresenta la coerenza dell'integrità referenziale del database, chiavi primarie univoche nelle tabelle, ecc.

• Isolation- È possibile che vengano elaborate molte transazioni con lo stesso set di dati contemporaneamente. Ogni transazione dovrebbe essere isolata dalle altre per prevenire il danneggiamento dei dati.

• Durability - Una volta completata una transazione, i risultati di questa transazione devono essere resi permanenti e non possono essere cancellati dal database a causa di un errore di sistema.

Un vero e proprio sistema di database RDBMS garantirà tutte e quattro le proprietà per ogni transazione. La visione semplicistica di una transazione emessa al database utilizzando SQL è la seguente:

• Inizia la transazione utilizzando il comando di inizio transazione .

• Eseguire varie operazioni di eliminazione, aggiornamento o inserimento utilizzando query SQL.

• Se tutte le operazioni hanno esito positivo, eseguire il commit altrimenti eseguire il rollback di tutte le operazioni.

Il framework Spring fornisce un livello astratto in cima a diverse API di gestione delle transazioni sottostanti. Il supporto per le transazioni di Spring mira a fornire un'alternativa alle transazioni EJB aggiungendo funzionalità di transazione ai POJO. Spring supporta la gestione delle transazioni sia programmatica che dichiarativa. Gli EJB richiedono un server delle applicazioni, ma la gestione delle transazioni Spring può essere implementata senza la necessità di un server delle applicazioni.

Transazioni locali e globali

Le transazioni locali sono specifiche per una singola risorsa transazionale come una connessione JDBC, mentre le transazioni globali possono estendersi su più risorse transazionali come la transazione in un sistema distribuito.

La gestione delle transazioni locali può essere utile in un ambiente informatico centralizzato in cui i componenti e le risorse dell'applicazione si trovano in un unico sito e la gestione delle transazioni coinvolge solo un gestore dati locale in esecuzione su una singola macchina. Le transazioni locali sono più facili da implementare.

La gestione delle transazioni globali è necessaria in un ambiente informatico distribuito in cui tutte le risorse sono distribuite su più sistemi. In tal caso, la gestione delle transazioni deve essere effettuata sia a livello locale che globale. Una transazione distribuita o globale viene eseguita su più sistemi e la sua esecuzione richiede il coordinamento tra il sistema di gestione delle transazioni globali e tutti i gestori di dati locali di tutti i sistemi coinvolti.

Programmatico vs dichiarativo

Spring supporta due tipi di gestione delle transazioni:

• Gestione delle transazioni programmatiche - Ciò significa che devi gestire la transazione con l'aiuto della programmazione. Questo ti dà un'estrema flessibilità, ma è difficile da mantenere.

• Gestione delle transazioni dichiarativa : significa separare la gestione delle transazioni dal codice aziendale. Utilizzi solo annotazioni o configurazioni basate su XML per gestire le transazioni.

La gestione delle transazioni dichiarativa è preferibile rispetto alla gestione delle transazioni programmatiche sebbene sia meno flessibile della gestione delle transazioni programmatiche, che consente di controllare le transazioni tramite il codice. Ma come una sorta di preoccupazione trasversale, la gestione dichiarativa delle transazioni può essere modularizzata con l'approccio AOP. Spring supporta la gestione delle transazioni dichiarative tramite il framework Spring AOP.

Astrazioni delle transazioni di primavera

La chiave per l'astrazione della transazione Spring è definita dall'interfaccia org.springframework.transaction.PlatformTransactionManager , che è la seguente:

public interface PlatformTransactionManager {
   TransactionStatus getTransaction(TransactionDefinition definition);
   throws TransactionException;
   
   void commit(TransactionStatus status) throws TransactionException;
   void rollback(TransactionStatus status) throws TransactionException;
}

Suor n	Metodo e descrizione
1	TransactionStatus getTransaction(TransactionDefinition definition) Questo metodo restituisce una transazione attualmente attiva o ne crea una nuova, in base al comportamento di propagazione specificato.
2	void commit(TransactionStatus status) Questo metodo esegue il commit della transazione data, in relazione al suo stato.
3	void rollback(TransactionStatus status) Questo metodo esegue un rollback della transazione data.

Il TransactionDefinition è l'interfaccia nucleo del supporto delle transazioni in primavera ed è definita come segue -

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

Suor n	Metodo e descrizione
1	int getPropagationBehavior() Questo metodo restituisce il comportamento di propagazione. Spring offre tutte le opzioni di propagazione delle transazioni familiari da EJB CMT.
2	int getIsolationLevel() Questo metodo restituisce il grado in cui questa transazione è isolata dal lavoro di altre transazioni.
3	String getName() Questo metodo restituisce il nome di questa transazione.
4	int getTimeout() Questo metodo restituisce il tempo in secondi in cui la transazione deve essere completata.
5	boolean isReadOnly() Questo metodo restituisce se la transazione è di sola lettura.

Di seguito sono riportati i possibili valori per il livello di isolamento:

Suor n	Isolamento e descrizione
1	TransactionDefinition.ISOLATION_DEFAULT Questo è il livello di isolamento predefinito.
2	TransactionDefinition.ISOLATION_READ_COMMITTED Indica che le letture sporche sono impedite; possono verificarsi letture non ripetibili e letture fantasma.
3	TransactionDefinition.ISOLATION_READ_UNCOMMITTED Indica che possono verificarsi letture sporche, letture non ripetibili e letture fantasma.
4	TransactionDefinition.ISOLATION_REPEATABLE_READ Indica che le letture sporche e non ripetibili sono impedite; possono verificarsi letture fantasma.
5	TransactionDefinition.ISOLATION_SERIALIZABLE Indica che le letture sporche, non ripetibili e fantasma sono impedite.

Di seguito sono riportati i possibili valori per i tipi di propagazione:

Sr.No.	Propagazione e descrizione
1	TransactionDefinition.PROPAGATION_MANDATORY Supporta una transazione in corso; genera un'eccezione se non esiste alcuna transazione corrente.
2	TransactionDefinition.PROPAGATION_NESTED Viene eseguito all'interno di una transazione nidificata se esiste una transazione corrente.
3	TransactionDefinition.PROPAGATION_NEVER Non supporta una transazione in corso; genera un'eccezione se esiste una transazione corrente.
4	TransactionDefinition.PROPAGATION_NOT_SUPPORTED Non supporta una transazione in corso; piuttosto eseguire sempre in modo non transazionale.
5	TransactionDefinition.PROPAGATION_REQUIRED Supporta una transazione in corso; ne crea uno nuovo se non esiste.
6	TransactionDefinition.PROPAGATION_REQUIRES_NEW Crea una nuova transazione, sospendendo la transazione corrente, se esistente.
7	TransactionDefinition.PROPAGATION_SUPPORTS Supporta una transazione in corso; viene eseguito in modo non transazionale se non esiste.
8	TransactionDefinition.TIMEOUT_DEFAULT Utilizza il timeout predefinito del sistema di transazione sottostante o nessuno se i timeout non sono supportati.

L' interfaccia TransactionStatus fornisce un modo semplice per il codice transazionale di controllare l'esecuzione della transazione e interrogare lo stato della transazione.

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}

Sr.No.	Metodo e descrizione
1	boolean hasSavepoint() Questo metodo restituisce se questa transazione contiene internamente un savepoint, cioè, è stata creata come transazione annidata basata su un savepoint.
2	boolean isCompleted() Questo metodo restituisce se questa transazione è stata completata, ovvero se è già stato eseguito il commit o il rollback.
3	boolean isNewTransaction() Questo metodo restituisce true nel caso in cui la transazione corrente sia nuova.
4	boolean isRollbackOnly() Questo metodo restituisce se la transazione è stata contrassegnata come solo rollback.
5	void setRollbackOnly() Questo metodo imposta la transazione come solo rollback.

Il framework Spring Web MVC fornisce l'architettura Model-View-Controller (MVC) e componenti pronti che possono essere utilizzati per sviluppare applicazioni web flessibili e liberamente accoppiate. Il pattern MVC consente di separare i diversi aspetti dell'applicazione (logica di input, logica di business e logica dell'interfaccia utente), fornendo al contempo un accoppiamento libero tra questi elementi.

• Il Model incapsula i dati dell'applicazione e in generale saranno costituiti da POJO.

• Il View è responsabile del rendering dei dati del modello e in generale genera output HTML che il browser del client può interpretare.

• Il Controller è responsabile dell'elaborazione delle richieste degli utenti e della creazione di un modello appropriato e lo passa alla vista per il rendering.

Il DispatcherServlet

Il framework MVC (model-view-controller) di Spring Web è progettato attorno a un DispatcherServlet che gestisce tutte le richieste e le risposte HTTP. Il flusso di lavoro di elaborazione delle richieste di Spring Web MVC DispatcherServlet è illustrato nel diagramma seguente:

Di seguito è riportata la sequenza di eventi corrispondenti a una richiesta HTTP in arrivo a DispatcherServlet -

• Dopo aver ricevuto una richiesta HTTP, DispatcherServlet consulta HandlerMapping per chiamare il controller appropriato .

• Il Controller accetta la richiesta e chiama i metodi di servizio appropriati in base al metodo GET o POST utilizzato. Il metodo del servizio imposterà i dati del modello in base alla logica di business definita e restituirà il nome della vista a DispatcherServlet .

• Il DispatcherServlet richiederà l'aiuto di ViewResolver per prelevare la vista definita per la richiesta.

• Una volta che la vista è stata finalizzata, il DispatcherServlet passa i dati del modello alla vista che viene infine visualizzata nel browser.

Tutti i componenti sopra menzionati, cioè HandlerMapping, Controller e ViewResolver sono parti di WebApplicationContext w che è un'estensione del semplice ApplicationContext con alcune funzionalità extra necessarie per le applicazioni web.

Configurazione richiesta

È necessario mappare le richieste che si desidera vengano gestite da DispatcherServlet , utilizzando una mappatura URL inweb.xmlfile. Quello che segue è un esempio per mostrare la dichiarazione e la mappaturaHelloWeb Esempio di DispatcherServlet -

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    
   <display-name>Spring MVC Application</display-name>
   
   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>

</web-app>

Il web.xmlil file verrà conservato nella directory WebContent / WEB-INF della tua applicazione web. All'inizializzazione diHelloWeb DispatcherServlet, il framework tenterà di caricare il contesto dell'applicazione da un file denominato [servlet-name]-servlet.xmlsi trova nella directory WebContent / WEB-INF dell'applicazione. In questo caso, il nostro file saràHelloWebservlet.xml.

Successivamente, il tag <servlet-mapping> indica quali URL verranno gestiti da quale DispatcherServlet. Qui tutte le richieste HTTP che terminano con.jsp sarà gestito da HelloWeb DispatcherServlet.

Se non si desidera utilizzare il nome file predefinito come [servlet-name] -servlet.xml e il percorso predefinito come WebContent / WEB-INF , è possibile personalizzare questo nome file e il percorso aggiungendo il listener servlet ContextLoaderListener nel file web.xml come segue -

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   
</web-app>

Ora, controlliamo la configurazione richiesta per HelloWeb-servlet.xmlfile, posizionato nella directory WebContent / WEB-INF dell'applicazione Web -

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

Di seguito sono riportati i punti importanti su HelloWeb-servlet.xml file -

• Il file [nome-servlet] -servlet.xml verrà utilizzato per creare i bean definiti, sovrascrivendo le definizioni di tutti i bean definiti con lo stesso nome nell'ambito globale.

• Il tag <context: component-scan ...> verrà utilizzato per attivare la capacità di scansione delle annotazioni Spring MVC che consente di utilizzare annotazioni come @Controller e @RequestMapping ecc.

• L' InternalResourceViewResolver avrà regole definite per risolvere i nomi delle viste. Secondo la regola sopra definita, una vista logica denominatahelloè delegato a un'implementazione della vista situata in /WEB-INF/jsp/hello.jsp .

La sezione seguente mostrerà come creare i componenti effettivi, ovvero controller, modello e vista.

Definizione di un controller

Il DispatcherServlet delega la richiesta ai controller di eseguire la funzionalità specifica. Il@Controllerl'annotazione indica che una particolare classe svolge il ruolo di controllore. Il@RequestMapping l'annotazione viene utilizzata per mappare un URL a un'intera classe o a un particolare metodo del gestore.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Il @Controllerl'annotazione definisce la classe come controller Spring MVC. Qui, il primo utilizzo di@RequestMapping indica che tutti i metodi di gestione su questo controller sono relativi a /hellosentiero. Annotazione successiva@RequestMapping(method = RequestMethod.GET)viene utilizzato per dichiarare il metodo theprintHello () come metodo di servizio predefinito del controller per gestire la richiesta HTTP GET. È possibile definire un altro metodo per gestire qualsiasi richiesta POST allo stesso URL.

Puoi scrivere il controller sopra in un'altra forma in cui puoi aggiungere attributi aggiuntivi in @RequestMapping come segue:

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Il value l'attributo indica l'URL a cui è mappato il metodo del gestore e il methodl'attributo definisce il metodo del servizio per gestire la richiesta HTTP GET. I seguenti punti importanti devono essere annotati sul controller sopra definito:

• Definirai la logica aziendale richiesta all'interno di un metodo di servizio. Puoi chiamare un altro metodo all'interno di questo metodo secondo i requisiti.

• In base alla logica di business definita, creerai un modello all'interno di questo metodo. È possibile utilizzare diversi attributi del modello setter e questi attributi saranno accessibili dalla vista per presentare il risultato finale. Questo esempio crea un modello con il suo attributo "messaggio".

• Un metodo di servizio definito può restituire una stringa, che contiene il nome di viewda utilizzare per il rendering del modello. Questo esempio restituisce "ciao" come nome della vista logica.

Creazione di viste JSP

Spring MVC supporta molti tipi di visualizzazioni per diverse tecnologie di presentazione. Questi includono: JSP, HTML, PDF, fogli di lavoro Excel, XML, modelli Velocity, XSLT, JSON, feed Atom e RSS, JasperReports, ecc. Ma più comunemente usiamo modelli JSP scritti con JSTL.

Scriviamo un semplice hello visualizza in /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Qui ${message}è l'attributo che abbiamo impostato all'interno del Controller. Puoi avere più attributi da visualizzare nella tua vista.

Esempi di framework Spring Web MVC

Sulla base dei concetti di cui sopra, controlliamo alcuni esempi importanti che ti aiuteranno a costruire le tue applicazioni Web Spring -

Sr.No.	Esempio e descrizione
1	Esempio Spring MVC Hello World Questo esempio spiegherà come scrivere una semplice applicazione Spring Web Hello World.
2	Esempio di gestione dei moduli Spring MVC Questo esempio spiega come scrivere un'applicazione Web Spring utilizzando moduli HTML per inviare i dati al controller e visualizzare un risultato elaborato.
3	Esempio di reindirizzamento della pagina di primavera Scopri come utilizzare la funzionalità di reindirizzamento delle pagine in Spring MVC Framework.
4	Esempio di pagine statiche di primavera Scopri come accedere a pagine statiche insieme a pagine dinamiche in Spring MVC Framework.
5	Esempio di gestione delle eccezioni di primavera Scopri come gestire le eccezioni in Spring MVC Framework.

Questa è una funzionalità Log4J molto facile da usare all'interno delle applicazioni Spring. Il seguente esempio ti guiderà attraverso semplici passaggi per spiegare la semplice integrazione tra Log4J e Spring.

Diamo per scontato che tu l'abbia già fatto log4Jinstallato sulla tua macchina. Se non ce l'hai, puoi scaricarlo dahttps://logging.apache.org/ed estrai semplicemente il file zippato in qualsiasi cartella. Useremo sololog4j-x.y.z.jar nel nostro progetto.

Quindi, disponiamo di un IDE Eclipse funzionante e intraprendiamo i seguenti passaggi per sviluppare un'applicazione Web dinamica basata su form utilizzando Spring Web Framework:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Aggiungi anche la libreria log4j log4j-xyzjar nel tuo progetto utilizzando Aggiungi JAR esterni .
4	Crea classi Java HelloWorld e MainApp nel pacchetto com.tutorialspoint .
5	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
6	Crea il file di configurazione log4J log4j.properties sottosrc cartella.
7	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file

package com.tutorialspoint;

public class HelloWorld {
   private String message;
   
   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage() {
      System.out.println("Your Message : " + message);
   }
}

Di seguito è riportato il contenuto del secondo file MainApp.java

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.log4j.Logger;

public class MainApp {
   static Logger log = Logger.getLogger(MainApp.class.getName());
   
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      log.info("Going to create HelloWord Obj");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      
      log.info("Exiting the program");
   }
}

Puoi generare debug e errormessaggio in modo simile a quando abbiamo generato messaggi informativi. Vediamo ora il contenuto diBeans.xml file

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Di seguito è riportato il contenuto di log4j.properties che definisce le regole standard richieste a Log4J per produrre messaggi di log

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
# Set the name of the file
log4j.appender.FILE.File=C:\\log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, overwrite
log4j.appender.FILE.Append=false

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio nella console Eclipse:

Your Message : Hello World!

Se controlli l'unità C: \\, dovresti trovare il file di registro log.out con vari messaggi di registro, come qualcosa come segue:

<!-- initialization log messages -->

Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the program

API Jakarta Commons Logging (JCL)

In alternativa puoi usare Jakarta Commons Logging (JCL)API per generare un registro nella tua applicazione Spring. JCL può essere scaricato dahttps://jakarta.apache.org/commons/logging/. L'unico file di cui abbiamo bisogno tecnicamente da questo pacchetto è il file commons-logging-xyzjar , che deve essere inserito nel tuo classpath in modo simile a come avevi inserito log4j-xyzjar nell'esempio precedente.

Per utilizzare la funzionalità di registrazione è necessario un oggetto org.apache.commons.logging.Log e quindi è possibile chiamare uno dei seguenti metodi in base alle proprie esigenze:

• fatale (messaggio oggetto)
• errore (messaggio oggetto)
• warn (messaggio oggetto)
• info (messaggio oggetto)
• debug (messaggio oggetto)
• trace (messaggio oggetto)

Di seguito è riportata la sostituzione di MainApp.java, che utilizza l'API JCL

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.logging. Log;
import org.apache.commons.logging. LogFactory;

public class MainApp {
   static Log log = LogFactory.getLog(MainApp.class.getName());

   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      log.info("Going to create HelloWord Obj");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();

      log.info("Exiting the program");
   }
}

Devi assicurarti di aver incluso il file commons-logging-xyzjar nel tuo progetto, prima di compilare ed eseguire il programma.

Ora mantenendo invariato il resto della configurazione e del contenuto nell'esempio sopra, se compili ed esegui la tua applicazione, otterrai un risultato simile a quello ottenuto usando l'API Log4J.