Spring è un framework di sviluppo open source per Java aziendale. 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 promuovere buone pratiche di programmazione abilitando un modello di programmazione basato su POJO.

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

• Lightweight- La primavera è leggera quando si tratta di dimensioni e trasparenza. La versione base di Spring Framework è di circa 2 MB.

• Inversion of control (IOC)- L'accoppiamento allentato si ottiene in primavera utilizzando la tecnica Inversion of Control. Gli oggetti danno le loro dipendenze invece di creare o cercare oggetti dipendenti.

• Aspect oriented (AOP) - Spring supporta la programmazione orientata agli aspetti e consente lo sviluppo coerente separando la logica di business dell'applicazione dai servizi di sistema.

• Container - Spring contiene e gestisce il ciclo di vita e la configurazione degli oggetti dell'applicazione.

• MVC Framework - 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.

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

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

Di seguito sono riportati i moduli del framework Spring:

• Modulo principale
• Modulo fagiolo
• Modulo contesto
• Modulo linguaggio di espressione
• Modulo JDBC
• Modulo ORM
• Modulo OXM
• Modulo JMS (Java Messaging Service)
• Modulo di transazione
• Modulo web
• Modulo Web-Servlet
• Modulo Web-Struts
• Modulo portlet Web

Il file di configurazione Spring è un file XML. Questo file contiene le informazioni sulle classi e descrive come queste classi sono configurate e presentate l'una all'altra.

Inversion of Control (IoC) è un concetto generale e può essere espresso in molti modi diversi e Dependency Injection è solo un esempio concreto di Inversion of Control.

Questo concetto dice che non crei i tuoi oggetti ma descrivi come dovrebbero essere creati. Non connetti direttamente i tuoi componenti e servizi insieme nel codice, ma descrivi quali servizi sono necessari per quali componenti in un file di configurazione. Un contenitore (il contenitore IOC) è quindi responsabile dell'aggancio del tutto.

I tipi di IoC sono:

• Constructor-based dependency injection - DI basato su costruttore viene realizzato quando il contenitore richiama un costruttore di classe con un numero di argomenti, ognuno dei quali rappresenta una dipendenza da un'altra classe.

• Setter-based dependency injection - 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.

Poiché è possibile combinare DI sia basato su costruttore che Setter, è una buona regola pratica utilizzare argomenti del costruttore per le dipendenze obbligatorie e setter per le dipendenze opzionali. Si noti che l'uso di un'annotazione @Required su un setter può essere utilizzato per rendere le dipendenze richieste dai setter.

I principali vantaggi del CIO o dell'iniezione di dipendenza sono:

• Riduce al minimo la quantità di codice nella tua applicazione.

• Rende la tua applicazione facile da testare in quanto non richiede alcun singleton o meccanismo di ricerca JNDI nei tuoi casi di unit test.

• L'accoppiamento allentato viene promosso con il minimo sforzo e il meccanismo meno invasivo.

• I contenitori IOC supportano l'istanza desiderosa e il caricamento lento dei servizi.

La programmazione orientata agli aspetti, o AOP, è una tecnica di programmazione che consente ai programmatori di modulare le preoccupazioni trasversali, o comportamenti che attraversano le tipiche divisioni di responsabilità, come la registrazione e la gestione delle transazioni. Il costrutto principale di AOP è l'aspetto, che incapsula i comportamenti che interessano più classi in moduli riutilizzabili.

Spring IoC crea gli oggetti, li collega insieme, li configura e gestisce il loro ciclo di vita completo dalla creazione alla distruzione. Il contenitore Spring utilizza l'inserimento delle dipendenze (DI) per gestire i componenti che compongono un'applicazione.

Esistono due tipi di contenitori IoC:

• Bean Factory container - Questo è il contenitore più semplice che fornisce supporto di base per DI. La BeanFactory è solitamente preferita dove le risorse sono limitate come dispositivi mobili o applicazioni basate su applet

• Spring ApplicationContext Container - Questo contenitore aggiunge funzionalità più specifiche dell'azienda come la capacità di risolvere messaggi di testo da un file delle proprietà e la capacità di pubblicare eventi dell'applicazione su listener di eventi interessati.

L'implementazione di BeanFactory più comunemente utilizzata è XmlBeanFactoryclasse. Questo contenitore legge i metadati di configurazione da un file XML e lo utilizza per creare un sistema o un'applicazione completamente configurati.

Le tre implementazioni comunemente utilizzate di 'Application Context' sono:

• FileSystemXmlApplicationContext- Questo contenitore carica le definizioni dei bean da un file XML. Qui è necessario fornire il percorso completo del file di configurazione del bean XML al costruttore.

• ClassPathXmlApplicationContext- Questo contenitore carica le definizioni dei bean da un file XML. Qui non è necessario fornire il percorso completo del file XML ma è necessario impostare correttamente CLASSPATH perché questo contenitore apparirà come file XML di configurazione del bean in CLASSPATH.

• WebXmlApplicationContext - Questo contenitore carica il file XML con le definizioni di tutti i bean dall'interno di un'applicazione web.

Di seguito sono riportate alcune delle differenze:

• I contesti dell'applicazione forniscono un mezzo per risolvere i messaggi di testo, incluso il supporto per i18n di tali messaggi.

• I contesti dell'applicazione forniscono un modo generico per caricare le risorse dei file, come le immagini.

• I contesti dell'applicazione possono pubblicare eventi su bean registrati come listener.

• Alcune operazioni sul contenitore o sui bean nel contenitore, che devono essere gestite in modo programmatico con una bean factory, possono essere gestite in modo dichiarativo in un contesto dell'applicazione.

• Il contesto dell'applicazione implementa MessageSource, un'interfaccia utilizzata per ottenere messaggi localizzati, con l'implementazione effettiva che può essere collegata.

Gli oggetti che costituiscono la spina dorsale della tua applicazione e che sono gestiti dal contenitore Spring IoC sono chiamati bean. 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 />.

La definizione del bean contiene le informazioni chiamate metadati di configurazione necessarie affinché il contenitore conosca quanto segue:

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

Sono disponibili tre metodi importanti per fornire i metadati di configurazione allo Spring Container:

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

Controlla il seguente esempio:

<?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.xsd">

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

</beans>

Quando si definisce un <bean> in Spring, 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. In modo simile, se vuoi che Spring restituisca la stessa istanza di bean ogni volta che ne è necessaria una, dovresti dichiarare l'attributo scope del bean come singleton.

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

• singleton - Questo ambito della definizione del bean a una singola istanza per contenitore Spring IoC.

• prototype - Questo scopo una singola definizione di bean per avere un numero qualsiasi di istanze di oggetti.

• request- Questo ambito da una definizione di bean a una richiesta HTTP. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.

• session- Questo ambito di una definizione di bean a una sessione HTTP. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.

• global-session- Questo ambito di una definizione di bean a una sessione HTTP globale. Valido solo nel contesto di Spring ApplicationContext compatibile con il Web.

L'ambito predefinito del bean è Singleton per il framework Spring.

No, i bean singleton non sono thread-safe nel framework Spring.

Di seguito è riportata la sequenza di un ciclo di vita dei fagioli in primavera:

• Instantiate - Per prima cosa il contenitore di primavera trova la definizione del bean dal file XML e istanzia il bean.

• Populate properties - Utilizzando l'inserimento delle dipendenze, spring popola tutte le proprietà come specificato nella definizione del bean.

• Set Bean Name - Se il bean implementa l'interfaccia BeanNameAware, spring passa l'id del bean al metodo setBeanName ().

• Set Bean factory - Se Bean implementa l'interfaccia BeanFactoryAware, spring passa il metodo beanfactory al metodo setBeanFactory ().

• Pre Initialization- Chiamato anche postprocess of bean. Se sono presenti bean BeanPostProcessor associati al bean, Spring chiama il metodo postProcesserBeforeInitialization ().

• Initialize beans- Se il bean implementa IntializingBean, viene chiamato il suo metodo afterPropertySet (). Se il bean ha la dichiarazione del metodo init, viene chiamato il metodo di inizializzazione specificato.

• Post Initialization - Se sono presenti BeanPostProcessor associati al bean, verranno chiamati i metodi postProcessAfterInitialization ().

• Ready to use - Ora il fagiolo è pronto per essere utilizzato dall'applicazione.

• Destroy - Se il bean implementa DisposableBean, chiamerà il metodo destroy ().

Un elemento <bean /> all'interno degli elementi <property /> o <constructor-arg /> definisce un cosiddetto bean interno. Una definizione di bean interno non richiede un ID o un nome definito; il contenitore ignora questi valori. Ignora anche il flag di ambito. I bean interni sono sempre anonimi e sono sempre definiti come prototipi.

Spring offre quattro tipi di elementi di configurazione della raccolta che sono i seguenti:

• <list> - Questo aiuta nel cablaggio, cioè iniettando un elenco di valori, consentendo duplicati.

• <set> - Questo aiuta a cablare un insieme di valori ma senza duplicati.

• <map> - Può essere utilizzato per iniettare una raccolta di coppie nome-valore in cui nome e valore possono essere di qualsiasi tipo.

• <props> - Questo può essere usato per iniettare una raccolta di coppie nome-valore in cui il nome e il valore sono entrambi stringhe.

Il contenitore Spring è in grado di cablare automaticamente le relazioni tra i bean che collaborano. Ciò significa che è possibile lasciare che Spring risolva automaticamente i collaboratori (altri bean) per il tuo bean ispezionando il contenuto di BeanFactory senza utilizzare gli elementi <constructor-arg> e <property>.

La funzionalità di autowiring ha cinque modalità che possono essere utilizzate per istruire il contenitore Spring a utilizzare l'autowiring per l'inserimento delle dipendenze -

• no- Questa è l'impostazione predefinita che significa nessun autowiring 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.

• byName- Autowiring dal nome della 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.

• 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 il suo tipo corrisponde esattamente a uno dei nomi dei bean nel file di configurazione. Se esistono più bean di questo tipo, viene generata un'eccezione irreversibile.

• constructor- Simile a byType, ma il tipo si applica agli argomenti del costruttore. Se non c'è esattamente un bean del tipo di argomento del costruttore nel contenitore, viene generato un errore irreversibile.

• autodetect - Spring prova prima a cablare usando autowire by constructor, se non funziona, Spring prova a autowire byType.

Le limitazioni del cablaggio automatico sono:

• Overriding possibility - È ancora possibile specificare le dipendenze utilizzando le impostazioni <constructor-arg> e <property> che sovrascriveranno sempre l'autowiring.

• Primitive data types - Non è possibile collegare automaticamente le cosiddette proprietà semplici come primitive, stringhe e classi.

• Confusing nature - Il cablaggio automatico è meno preciso del cablaggio esplicito, quindi, se possibile, preferisci utilizzare il cablaggio esplicito.

Sì.

Un'alternativa alle impostazioni XML è fornita dalla configurazione basata sull'annotazione che si basa sui metadati del bytecode per il cablaggio dei componenti invece delle dichiarazioni delle parentesi angolari. Invece di utilizzare XML per descrivere un cablaggio di bean, lo sviluppatore sposta la configurazione nella stessa classe del componente utilizzando le annotazioni sulla classe, sul metodo o sulla dichiarazione del campo pertinente.

Per impostazione predefinita, il cablaggio delle annotazioni non è attivato nel contenitore Spring. Quindi, prima di poter usare il cablaggio basato sulle annotazioni, dovremo abilitarlo nel nostro file di configurazione Spring configurando <context: annotation-config />.

Questa annotazione indica semplicemente che la proprietà del bean interessato deve essere popolata al momento della configurazione, tramite un valore di proprietà esplicito in una definizione di bean o tramite il cablaggio automatico. Il contenitore genera BeanInitializationException se la proprietà del bean interessato non è stata popolata.

Questa annotazione fornisce un controllo più dettagliato su dove e come eseguire il cablaggio automatico. L'annotazione @Autowired può essere utilizzata per autowire il bean sul metodo setter proprio come l'annotazione @Required, il costruttore, una proprietà o metodi con nomi arbitrari e / o più argomenti.

Potrebbe esserci una situazione in cui crei più di un bean dello stesso tipo e desideri collegarne solo uno con una proprietà, in tal caso puoi usare l'annotazione @Qualifier insieme a @Autowired per rimuovere la confusione specificando quale bean esatto sarà cablato.

Spring ha annotazioni basate su JSR-250 che includono annotazioni @PostConstruct, @PreDestroy e @Resource.

• @PostConstruct - Questa annotazione può essere utilizzata come alternativa al callback di inizializzazione.

• @PreDestroy - Questa annotazione può essere utilizzata come alternativa alla richiamata di distruzione.

• @Resource - Questa annotazione può essere utilizzata sui campi o sui metodi setter. L'annotazione @Resource accetta un attributo 'name' che verrà interpretato come il nome del bean da iniettare. Si può dire che segue la semantica di autowiring per nome.

L'opzione di configurazione basata su Java consente di scrivere la maggior parte della configurazione Spring senza XML ma con l'aiuto di poche annotazioni basate su Java.

Ad esempio: Annotazione @Configurationindica che la classe può essere utilizzata dal contenitore Spring IoC come origine delle definizioni dei bean. Il@Bean annotation dice a Spring che un metodo annotato con @Bean restituirà un oggetto che dovrebbe essere registrato come bean nel contesto dell'applicazione Spring.

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:

• ContextRefreshedEvent- Questo evento viene pubblicato quando ApplicationContext viene inizializzato o aggiornato. Questo può anche essere generato utilizzando il metodo refresh () sull'interfaccia ConfigurableApplicationContext.

• ContextStartedEvent- Questo evento viene pubblicato quando ApplicationContext viene avviato utilizzando il metodo start () sull'interfaccia ConfigurableApplicationContext. È possibile eseguire il polling del database oppure è possibile riavviare / avviare qualsiasi applicazione interrotta dopo aver ricevuto questo evento.

• 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.

• 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.

• RequestHandledEvent - Questo è un evento specifico del web che dice a tutti i bean che una richiesta HTTP è stata soddisfatta.

Un modulo che dispone di 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. In Spring AOP, gli aspetti vengono implementati utilizzando classi regolari (l'approccio basato su schema) o classi regolari annotate con l'annotazione @Aspect (stile @AspectJ).

Concern- La preoccupazione è il comportamento che vogliamo avere in un modulo di un'applicazione. La preoccupazione può essere definita come una funzionalità che vogliamo implementare. Le questioni a cui siamo interessati definiscono le nostre preoccupazioni.

Cross-cutting concern- È una preoccupazione che è applicabile in tutta l'applicazione e interessa l'intera applicazione. ad esempio, la registrazione, la sicurezza e il trasferimento dei dati sono le preoccupazioni necessarie in quasi tutti i moduli di un'applicazione, quindi sono problemi trasversali.

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.

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.

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.

Un'introduzione consente di aggiungere nuovi metodi o attributi alle classi esistenti.

L'oggetto essendo consigliato da uno o più aspetti, questo oggetto sarà sempre un oggetto proxy. Indicato anche come oggetto consigliato.

La tessitura è il processo di collegamento di aspetti con altri tipi di applicazioni o oggetti per creare un oggetto consigliato.

La tessitura può essere eseguita in fase di compilazione, caricamento o in fase di esecuzione.

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

• before - Esegui consigli prima dell'esecuzione di un metodo.

• after - Esegui un consiglio dopo l'esecuzione del metodo, indipendentemente dal suo risultato.

• after-returning - Esegui il consiglio dopo l'esecuzione del metodo a solo se il metodo viene completato correttamente.

• after-throwing - Esegui un consiglio dopo l'esecuzione del metodo a solo se il metodo esce generando un'eccezione.

• around - Esegui consigli prima e dopo che il metodo consigliato è stato richiamato.

Gli aspetti vengono implementati utilizzando classi regolari insieme alla configurazione basata su XML.

@AspectJ fa riferimento a uno stile di dichiarazione degli aspetti come normali classi Java annotate con annotazioni Java 5.

JDBC può essere utilizzato in modo più efficiente con l'aiuto di una classe template fornita dal framework spring chiamata JdbcTemplate.

Con l'uso del framework Spring JDBC, l'onere della gestione delle risorse e della gestione degli errori si riduce notevolmente. Quindi lascia agli sviluppatori la scrittura delle istruzioni e delle query per ottenere i dati da e verso il database. JdbcTemplate fornisce molti metodi utili per eseguire operazioni come la conversione dei dati del database in primitive o oggetti, l'esecuzione di istruzioni preparate e richiamabili e la gestione personalizzata degli errori del database.

Spring supporta due tipi di gestione delle transazioni:

• Programmatic transaction management- Ciò significa che hai gestito la transazione con l'aiuto della programmazione. Questo ti dà un'estrema flessibilità, ma è difficile da mantenere.

• Declarative transaction management- Ciò significa separare la gestione delle transazioni dal codice aziendale. Si utilizzano solo annotazioni o configurazione basata su XML per gestire le transazioni.

La gestione delle transazioni dichiarativa è preferibile rispetto alla gestione delle transazioni a livello di codice, sebbene sia meno flessibile della gestione delle transazioni a livello di codice, che consente di controllare le transazioni tramite il codice.

Il framework Spring Web MVC fornisce un'architettura model-view-controller e componenti pronti che possono essere utilizzati per sviluppare applicazioni Web flessibili e liberamente accoppiate. Il modello 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 framework Spring Web MVC è progettato attorno a un DispatcherServlet che gestisce tutte le richieste e le risposte HTTP.

Il WebApplicationContext è un'estensione del semplice ApplicationContext che ha alcune funzionalità extra necessarie per le applicazioni web. Si differenzia da un normale ApplicationContext in quanto è in grado di risolvere temi e sa a quale servlet è associato.

Di seguito sono riportati alcuni dei vantaggi di Spring MVC rispetto a Struts MVC:

• L'MVC di Spring è molto versatile e flessibile in base alle interfacce, ma Struts forza le azioni e gli oggetti Form in un'eredità concreta.

• Spring fornisce sia intercettori che controllori, quindi aiuta a escludere comportamenti comuni per la gestione di molte richieste.

• Spring può essere configurato con diverse tecnologie di visualizzazione come Freemarker, JSP, Tiles, Velocity, XLST ecc. E puoi anche creare il tuo meccanismo di visualizzazione personalizzato implementando l'interfaccia Spring View.

• In Spring i controller MVC possono essere configurati utilizzando DI (IOC) che ne semplifica il test e l'integrazione.

• Il livello Web di Spring MVC è facile da testare rispetto al livello Web di Struts, a causa dell'evitamento dell'ereditarietà concreta forzata e della dipendenza esplicita dei controller dal servlet del dispatcher.

• Struts costringe i tuoi controller ad estendere una classe Struts ma Spring no, ci sono molte implementazioni di controller che puoi scegliere di estendere.

• In Struts, le azioni sono accoppiate alla vista definendo ActionForwards all'interno di un ActionMapping o globalmente. SpringMVC dispone di un'interfaccia HandlerMapping per supportare questa funzionalità.

• Con Struts, la convalida viene solitamente eseguita (implementata) nel metodo di convalida di un ActionForm. In SpringMVC, i validatori sono oggetti di business che NON dipendono dall'API Servlet che fa sì che questi validatori vengano riutilizzati nella logica aziendale prima di rendere persistente un oggetto di dominio in un database.

I controller forniscono l'accesso al comportamento dell'applicazione definito in genere tramite un'interfaccia di servizio. I controller interpretano l'input dell'utente e lo trasformano in un modello rappresentato all'utente dalla vista. Spring implementa un controller in un modo molto astratto, che consente di creare un'ampia varietà di controller.

L' annotazione @Controller indica che una particolare classe svolge il ruolo di controller. Spring non richiede di estendere alcuna classe di base del controller o di fare riferimento all'API servlet.

L' annotazione @RequestMapping viene utilizzata per mappare un URL a un'intera classe o a un particolare metodo del gestore.

Ci sono due modi per accedere all'ibernazione usando la primavera:

• Inversione del controllo con un modello di ibernazione e richiamata.

• Estensione del supporto HibernateDAOS e applicazione di un nodo AOP Interceptor.

Spring supporta i seguenti ORM:

• Hibernate
• iBatis
• JPA (Java Persistence API)
• TopLink
• JDO (Java Data Objects)
• OJB