Spring IntroUna panoramica del framework open source

Giovedì 18 febbraio 2016

Programma della mattinata

9.45 - 10.45: Primo Modulo

➢ Introduzione a Spring Framework➢ Panoramica delle componenti principali➢ IoC e Dependency Injection➢ Configurazione del context

10.45 - 11.00: coffee break

Programma della mattinata

11.00 - 11.45: Secondo Modulo

➢ Spring MVC➢ Introduzione alla configurazione MVC➢ Spring Controllers➢ Spring Hateoas: REST Support

11.45 - 12.00: Q&A e conclusione dei lavori

Introduzione a Spring Framework

Il più diffuso framework open-source per lo sviluppo di applicazioni in ambiente Java EE:

● Adottato ormai come uno standard de facto● Non invasivo● Modulare● Facilita lo sviluppo, occupandosi delle operazioni base e lasciando

al programmatore il focus sulla logica di business● Promuove pratiche di programmazione virtuose e l’uso di design

patterns

Core Container

● Core & Beanscompongono la parte fondamentale del framework e forniscono funzionalità quali IoC e Dependency Injection

● Contextfornisce un metodo di accesso agli oggetti gestiti da Spring, in modo simile ad un registro

● Expression languagefornisce un potente linguaggio per leggere e manipolare oggetti a runtime (jsp, security, ecc..)

AOP, Aspect, Instrumentation

● AOPimplementazione AOP Alliance-compliant che permette all’utente di definire intercettori e punti di controllo per disaccoppiare funzionalità distinte

● Aspectintegrazione con AspectJ

● Instrumentationclassi di supporto e classloaders per vari applications server (spring-instrumentation-tomcat)

Data Access Integration

● JDBC● ORM

integrazione con framework come Hibernate e iBatis

● OXMintegrazione con framework di mapping Obj/xml (jaxb, castor, ecc..)

● JMS● Transaction

per la gestione programmatica delle transazioni

WEB

● Weboffre funzionalità base per applicazioni web-oriented, come l’upload multipart e l’inizializzazione del container IoC attraverso l’uso di Servlet Listeners

● WebMVC (web servlet)fornisce le implementazioni per il pattern model-view-controller e i protocolli REST

● WebMVC - Portletcome la precedente, ma implementa il protocollo JSR-286 (portlet 2.0)

IoC e Dependency Injection

● IoC Pattern

● Le basi del Container IoC

IoC Pattern

Un’applicazione Java consiste tipicamente in un insieme di componenti (oggetti) che collaborano tra loro in diversi modi, generando delle dipendenze tra di loro.

Una delle lacune di Java è la mancanza di un metodo standard per la gestione e l’organizzazione dei blocchi principali di un’applicazione.

La soluzione è lasciata all’architetto (o molto spesso al programmatore stesso), che si può affidare ai Design Patterns.

IoC Pattern

IoC Pattern

Spring utilizza il principio chiamato Inversion of Control (IoC) per gestire questa complessità, fornendo una modalità per comporre i diversi oggetti di un’applicazione in un unico progetto coerente.

Implementa una serie di pattern che possono essere utilizzati in modo semplice dall’utente.

Il Dependency Injection è una modalità con la quale viene realizzato IoC.

IoC Pattern

Il Dependency Injection è un processo attraverso il quale gli oggetti definiscono le proprie dipendenze, in tre modalità:

● Argomenti del Construttore● Argomenti ad un Factory Method● Proprietà che devono essere settate (setters)

Il Container si occupa di iniettare queste dipendenze, in modo automatico, invertendo di fatto il processo di creazione degli oggetti.

IoC Pattern

Le basi del Container IoC

L’interfaccia ApplicationContext rappresenta il Container IoC Spring.

E’ responsabile della creazione, configurazione e assemblaggio dei beans.

Le basi del Container IoC

Le istruzioni per la creazione dei beans vengono caricate dai metadati di configurazione, che sono rappresentati da:

● XML● Java Annotations● Java Configuration

Questi metadati esprimono le dipendenze tra gli oggetti gestiti nella nostra applicazione.

Configurazione del Context

● Creazione di un context: xml, annotation e configuration● Inizializzazione di un Container IoC: standalone e web● Uso del Container IoC

Creazione di un Context: XML

Creazione di un Context: Annotation

Creazione di un Context: Annotation

Per essere attivo richiede la configurazione preventiva di uno scanner per individuare le annotation:

Le injection via Annotation vengono chiamate prima di quelle dichiarate via configuazione xml.

Creazione di un Context: Annotation

Esiste una gerarchia di Stereotipi che ci aiuta a definire il ruolo dei nostri oggetti all’interno della struttura dell’applicazione:

Creazione di un Context: Java Config

Inizializzazione di un Container IoC

In modalità “stand-alone” (cioè non web) un context può essere inizializzato caricando un metadato (xml config) o registrando una o più classi di configurazione (java config)

Inizializzazione di un Container IoC

Un esempio di caricamento tramite configurazione Java

Inizializzazione di un Container IoC

Uso del Container IoC

Abbiamo già visto che l’interfaccia ApplicationContext rappresenta il nostro Container e inizializza il context.

Una volta inizializzato il context possiamo recuperarlo nei nostri bean (ServletContextAware)

● @Autowired e @Valuepossono essere wirate anche Collections<T> dove T è in una gerarchia di beans gestiti

● context.getBean(String name, Class<T> requiredType)

Uso del Container IoC

Spring MVC

● Spring web-mvc● Il Pattern MVC● Spring MVC architetture● Dispatcher Servlet● Componenti principali

Spring web-MVC

Spring web-mvc è un modulo di Spring che possiamo utilizzare nei nostri progetti.

E’ il modulo di riferimento per le applicazioni web (sia classiche che REST)

Implementa il pattern Model - View - Controller

Il Pattern MVC

MVC è un pattern architetturale di “front-end” per l’interazione con altri sistemi.

Si basa sull’interazione di tre componenti principali, opportunamente configurati.

Il Pattern MVC

Rappresentazione del flusso di esecuzione in un pattern mvc

Spring MVC Architecture

Assumendo l’uso di jsp, possiamo rappresentare così l’archiettura mvc implementata da Spring

Spring MVC Architecture

● DispatcherServlet: single point of access per le richieste● Controller: si occupa di elaborare le richieste e costruire gli

elementi necessari per inviare la risposta● View: si occupa di renderizzare i dati contenuti nel model● ModelAndView: incapsula la relazione tra view e model,

contenendo i dati (model) e il nome logico della vista● Model/ModelMap: contiene i dati (tipicamente pojo) che servono

per il rendering finale della vista

Dispatcher Servlet

E’ la servlet principale dell’applicazione, nella maggior parte dei casi, l’unica servlet definita.

Si occupa anche di inizializzare i componenti del framework che servono a processare le richieste (interceptor, view resolver, internationalization, ecc..)

Gestisce tutte le richieste in arrivo e le dirotta ai vari controller, determinando quale di essi sia deputato a gestire la richiesta specifica

Utilizza un design pattern chiamato Front Controller.

Dispatcher Servlet

Deve essere inizializzata nel web.xml.

E’ richiesta la creazione di un WebApplicationContext per ogni servlet definita.

.. ricordate il secondo contesto definito durante la creazione del progetto? Vediamolo insieme!

Componenti principali: Controller

● E’ responsabile di ricevere le richieste dall’utente (o dal browser)● Interpreta e valida gli input dell’utente● Trasforma gli input ricevuti in oggetti più o meno complessi● Si occupa di creare e popolare il model, utilizzando i servizi

sottostanti● All’interno di un’applicazione Spring, può essere riconosciuto per

dall’annotation @Controller

Componenti principali: Model

● Il Model è un contenitore di oggetti (pojo o beans) che saranno inviati alla view per essere rappresentati

● Tipicamente viene implementato attraverso una Map<String, Object>

● All’interno di un’applicazione Spring web troveremo spesso un oggetto di tipo ModelAndView, che incapsula la relazione tra model e view e viene ritornato dal controller

Componenti principali: View

● Si occupa di renderizzare l’output finale da ritornare al browser o all’invocante

● Possono essere utilizzate diverse tecnologie per la realizzazione della view, ad esempio:○ jsp○ tiles○ velocity○ struts○ ecc

● Spring utilizza uno (o più) bean per matchare il nome della view definito nel controller con un oggetto specifico da processare (un file jsp, un template velocity, ecc..)

Introduzione alla configurazione MVC

● Guardiamo insieme un esempio di contesto● View Resolution

Configurazione MVC

All’interno del file di esempio possiamo discutere gli elementi principali di questo context:

- <context:annotation-config />- component-scan - <mvc:annotation-driven/>- <mvc:default-servlet-handler/>- esempi di view resolver- <mvc:argument-resolvers />- <mvc:interceptors />- security

View Resolution

Possiamo definire più beans che si occupino di matchare il nome logico di una vista con un bean/file/template.

Tutti questi beans implementano due interfacce:

- ViewResolver- Ordered

Questi resolvers dovrebbero sempre essere ordinati e la risoluzione avviene per pattern matching. Possiamo definire più beans che si occupino di matchare il nome logico di una vista con un bean/file/template.

Spring Controllers

● Definizione di un Controller● Request Mapping● Parameter Injection● RequestBody e ResponseBody

Definizione di un Controller

Lo stereotipo @Controller identifica una classe deputata alla gestione di una o più richieste http.

L’annotation @RequestMapping è utilizzata per definire il mapping tra le richieste, definite come url + parametri, e i metodi deputati alla gestione.

Può essere utilizzata a livello di classe, per definire un path specifico valido per tutti i metodi, o a livello di metodo.

Accetta una serie di parametri che analizzeremo tra poco.

@Request Mapping

Definisce il mapping tra url e classe/metodo di gestione Properties disponibili:

● Value: definisce il path url a cui il metodo risponde● Method: definisce l’elenco dei metodi HTTP che il metodo

supporta (GET, POST, OPTION, PUT, ecc..)● Consumes/produces: definisce il mimetype del contenuto che

il metodo supporta. Il mimetype è usato per fare il marshalling e l’unmarshalling del contenuto della request e della response (esempio: text/html, application/json, ecc..)Alcuni mimetype richiedono converters (json, xml,..)

@Request Mapping

Parameter Injection: URI Templates

Spring ci permette di definire delle variabili all’interno dei nostri path e di gestire queste variabili come parametri in ingresso al controller:

- supportano regular expressions- valido solo per tipi primitivi (wrapper), String e Date

Parameter Injection: HTTP Params

Spring ci permette di definire i parametri della nostra richiesta (GET, POST) come parametri in ingresso al controller:

- default per tipi primitivi (wrapper), String e Date- possono essere estesi con i DataBinding- supportano le properties: value, required e defaultValue

Parameter Injection: HTTP Params

Possiamo tranquillamente utilizzare tutti questi metodi di injection dei parametri, Spring cercherà il miglior match possibile (o ritornerà 404 se nessun match è possibile)

@RequestBody

Indica a Spring che l’intero body della nostra request deve essere mappato su un unico oggetto java.

Deve esistere un converter valido per questo oggetto!

@ResponseBody

Indica a Spring che l’intero body della nostra response deve essere popolato con il valore del tipo di ritorno del metodo.

Anche in questo caso deve essere utilizzato un converter valido tra l’oggetto java e il mimetype in output dichiarato dal metodo.

Utilizzato molto spesso in ambiti REST.

Esempio di una vista

Spring Hateoas: REST Support

● ResourceSupport● Utilizzo di @RestController● Gestione chiamate Cross-Origin

Resource Support

La funzionalità principale del pacchetto Hateoas è l’introduzione della classe ResourceSupport

Supporta nativamente la conversione in JSON, tramite la libreria jackson

In ambito REST, ogni metodo che ritorna un dato (@ResponseBody) dovrebbe ritornare:

HttpEntity<T extends ResourceSupport>

@Rest Controller

Novità di Spring 4.0, definito come meta annotation:

@Controller + @ResponseBody

L’annotation @ResponseBody viene propagata a livello di metodo, quindi non è più necessario indicarla su ogni singolo metodo.

Da Spring 4.2 (Luglio 2015) supporta l’utilizzo di @JsonView per definire proiezioni di dati.

@Json View

Gestione di chiamate Cross Origin

Una chiamata http viene definita Cross Origin quando l’initiator e la destination hanno due domain name diversi (protocol + server name + port).

Spesso utilizzate per chiamate ajax.

Caso tipico applicazioni REST + frontend javascript!

Gestione di chiamate Cross Origin

Fino a poco tempo fare era necessario implementare un filtro

Da Spring 4.2 non serve più!

@CrossOrigin permette di modellare questo comportamento, aggiungendo gli header corretti

Q&A

Domande? Dubbi?

Grazie per l’attenzione!

Per saperne di più sui nostri corsi di formazione visita

www.miriade.it/training