Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Java EE: Java Server Pages vs Java Server Faces

A cosa serve realmente la specifica JSF? Quanto i framework basati su JSF2 migliorano lo sviluppo della parte presentazionale di applicazioni Java EE rispetto a JSP? Vediamo come, a differenza di JSP, in JSF ad ogni pagina (view) corrisponda un managed bean, attraverso un particolare tipo di Expression Language
A cosa serve realmente la specifica JSF? Quanto i framework basati su JSF2 migliorano lo sviluppo della parte presentazionale di applicazioni Java EE rispetto a JSP? Vediamo come, a differenza di JSP, in JSF ad ogni pagina (view) corrisponda un managed bean, attraverso un particolare tipo di Expression Language
Link copiato negli appunti

Le Java Server Pages (JSP) hanno costituito per molti anni l'unica tecnologia disponibile nella costruzione del Presentation Layer mediante pagine dinamiche.
Negli ultimi anni però sono state introdotte nuove tecnologie che hanno facilitato e reso più agevole la creazione dell'interfaccia utente (UI): fra queste Java Server Faces è senza dubbio quella che ha riscosso maggiore successo.
In questo articolo illustreremo quelle che sono le principali differenze fra JSP e JSF.

Confronto dei modelli logici

Una prima evidente differenza fra le tecnologie JSP e JSF può essere messa in rilievo confrontando la logica presente dietro il funzionamento dell'una e dell'altra tecnologia.

Le JSP sono costituite da una combinazione di testo e tag: il testo rappresenta il contenuto informativo mentre i tag partecipano alla costruzione delle pagine dinamiche decidendone ad esempio la formattazione, eventuali controlli etc.

È possibile includere all'interno di una JSP delle parti di codice attraverso le cosiddette scriplet:

<% ... codice java %>

O fare riferimento a bean presenti ad esempio nella sessione utente:

<jsp:use-bean id="identificatore" class="miopackage.mioBean" scope="session" />

In ogni caso è compito del programmatore definire tutta la logica di conversione dei valori inseriti dall'utente nei corrispondenti tipi utilizzati dagli oggetti a backend, effettuare controlli di validità sui valori inseriti (ad esempio se un valore intero ricade all'interno di un intervallo di validità o meno), e via dicendo.

In JSF invece la logica, solo apparentemente più complessa, facilita di gran lunga la costruzione del layer di presentazione.

In JSF ogni view (pagina) è associata ad un managed bean, un managed-bean o backing-bean è un POJO (Plain Old Java Object) ovvero un oggetto costituito da proprietà e metodi di get e set.
Così ad ogni campo di input presente all’interno della pagina è associata ad una proprietà del managed bean attraverso un'espressione EL (Expression Language), come nel seguente esempio:

<h:inputText binding="#{gsbean.componente}" />

La configurazione dei managed-bean avviene all'interno del faces-config.xml nel seguente modo:

<managed-bean>
<managed-bean-name>miobean</managed-bean-name>
<managed-bean-class>miopackage.MioBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
<managed-property>
<property-name>proprieta</property-name>
<property-class>int</property-class>
<value>0</value>
</managed-property>
</managed-bean>

convertitori e validatori in JSF

JSF mette inoltre a disposizione la logica per la conversione dei tipi e la validazione attraverso l'utilizzo di convertitori e validatori.

In generale la conversione dei tipi primitivi viene effettuata automaticamente mentre la conversione in tipi più complessi (quali ad esempio le date) prevede l'indicazione del convertitore da utilizzare, come nel seguente esempio:

<h:inputText value="#{miobean.miadata}">
<f:convert converterID="javax.faces.DateTime" />
</h:inputText>

Allo stesso modo JSF permette di definire dei validatori per i valori inseriti dall'utente:

<h:inputText value="#{miobean.valore}" required="true">
<f:validator validatorID="id_validatore"/>
</h:inputText>

Confronto dei cicli di vita

È possibile evidenziare le principali differenze fra JSP e JSF a partire dal confronto fra il ciclo di vita di JSF rispetto a quello tipico delle JSP: per ciclo di vita intendiamo gli stati che attraversano le due tecnologie dalla creazione della pagina alla distruzione.

Il ciclo di vita di una JSP

Il ciclo di vita di una JSP è piuttosto semplice: quando viene richiesta una pagina jsp al container web, questo provvede a convertire la pagina in una servlet e ad autorizzare la servlet a processare la richiesta utente, una volta che la pagina viene trasformata in una servlet, la stessa servlet verrà utilizzata per processare successive richieste.

È opportuno ricordare che la compilazione della jsp in servlet avviene tutte le volte che la jsp subisce delle modifiche.

Il ciclo di vita di JSF

Il ciclo di vita di Java Server Faces è molto più complesso di quello di una jsp e consta di 6 diverse fasi:

  1. Restore View: è la fase di inizializzazione della view. Durante questa fase si procede alla costruzione della view della pagina, dei gestori degli eventi, dei validatori e dei componenti presenti nella vista.
  2. Apply Request Values: durante questa fase vengono estratti i valori dalla request e convertiti nei tipi previsti dal managed bean.
  3. Process Validation: è la fase di validazione dei valori inseriti dall'utente secondo le logiche di validazione definite.
  4. Update Model Values: vengono aggiornate le proprietà del managed bean con i valori inseriti dall'utente se questi hanno superato la fase di validazione.
  5. Invoke Application: in questa fase vengono gestiti gli eventi applicative (quail ad esempio il click su un bottone) .
  6. Render Response: viene renderizzata la view.

Confronto dei modelli di navigazione

Un altro aspetto di fondamentale importanza nella valutazione di una tecnologia di presentation è costituito dal modello di navigazione.

Per modello di navigazione intendiamo la logica attraverso al quale una web-application transita da una view a quella immediatamente successiva a seconda dell’input utente.

La navigazione in JSP

In JSP non è presente un modello di navigazione vero e proprio e spetta al programmatore l'onere di reindirizzare di volta in volta l'applicazione verso l'una o l'altra pagina.

La navigazione in JSF

In JSF invece il modello di navigazione fa uso di un insieme di regole di navigazione che vengono attivate mediante degli outcome.Per comprendere il funzionamento del modello di navigazione in JSF consideriamo la seguente regola di navigazione:

<navigation-case>
<from-action>#{miobean.verifica1}</from-action>
<from-outcome>successo</from-outcome>
<to-view-id>/successo1.jsp</to-view-id>
</navigation-case>

Tale regola afferma che, se viene invocata l’azione verifica1 del miobean e questa restituisce come outcome la stringa "successo" allora bisogna passare alla pagina successo1.jsp.

Verso le Facelets

Quando fu introdotta la tecnologia JavaServer Faces si pensava di utilizzarla congiuntamente alle JavaServer Pages nella creazione delle pagine di una web application.
Il ciclo di vita JavaServer Faces, come abbiamo visto, è però composto da diverse fasi e a differenza di JSP che processa gli elementi di una pagina nell’ordine in cui questi appaiono, JSF organizza i componenti di una pagina in una complessa struttura ad albero: tali differenze pongono in essere una serie di incompatibilità fra queste due tecnologie.

Le Facelets, introdotte in JSF 2.0, nascono per sostituire JSP nella creazione delle pagine, superando tali incompatibilità e fornendo i seguenti vantaggi:

  1. indipendenza dal web container
  2. compatibilità con qualsiasi versione JSF
  3. supporto per il templating

È ragionevole pensare quindi che in futuro più o meno prossimo si farà sempre meno uso di JSP per abbracciare le "nuove" specifiche JSF.


Ti consigliamo anche