4 Facce in padella – oggi ancora più Ricche (Getting started with JBoss RichFaces 4.x)

rf_logoIl progetto RichFaces è un framework di componenti UI avanzati, progettato per una agevole integrazione di funzionalità Ajax all’interno di applicazioni business, usando JavaServer Faces (JSF). Il 30 Marzo è uscita la attesa nuova versione, JBoss RichFaces 4.0, che introduce il pieno supporto alla specifica 2.0 delle JSF, una serie di novità interessanti e soprattutto molto più sapore! Cosa stiamo aspettando? Vediamo insieme come cucinarci un bel Hello World!

La ricerca degli ingredienti

Total Eclipse of the heart

eclipsePrima di tutto ci serve un IDE: se ne volete uno fresco, che piace a tutti e con poche calorie potete assaggiare Eclipse. Scarichiamo l’ultima versione, Helios SR2. Abbiamo già visto insieme come scaricare e "installare" Eclipse nel post Hello World in Java con Eclipse, ricordate?

L’application server: JBoss AS 6

Come application server per questa ricetta utilizzeremo JBoss 6: anche se è un ingrediente di altissima qualità lo trovate ovunque, anche nei supermercati; per comodità scarichiamolo dalla pagina di download di JBoss nella sua versione 6.0 Final (jboss-as-distribution-6.0.0.Final.zip) e attendiamo che termini il corposo download (circa 181 Mb).

Gli strumenti dello chef: i JBoss Tools

jboss_toolsOra che abbiamo installato JBoss non resta che creare un nuovo server all’interno di Eclipse. In realtà non esiste un adapter già pronto per JBoss 6 e anche se utilizziamo il Download new server adapter non lo troviamo. D’altro canto sappiamo che ogni bravo chef che prepara una nuova ricetta ha bisogno degli strumenti giusti. Per questa ricetta ci viene nuovamente in soccorso JBoss, con i suoi JBoss Tools.

Per scaricarli ed installarli:

  • Avviamo Eclipse
  • Andiamo nel menu Help > Install New Software
  • Premiamo su Add…
  • Inseriamo JBoss Tools in Name e http://download.jboss.org/jbosstools/updates/development/ in Location
  • Se siamo interessati solo all’adapter basta selezionare JBoss AS Tools
  • Portiamo a fondo lo wizard

Ecco fatto! Al termine avremo a disposizione i server plugin forniti da JBoss, incluso quello che supporta la versione 6.0

JBoss RichFaces 4.0

Bene, adesso andiamo a prenderci le Facce. Queste stanno benissimo con gli ingredienti visti finora e la nuova ricetta aggiunge molto più gusto allo sviluppo, senza aumentare il numero di calorie. Una volta terminato il download (questa volta ce la caviamo con meno di 10 Mb!) scompattiamo delicatamente il file richfaces-4.0.0.Final.zip col nostro unzippatore di fiducia (per chi si stesse chiedendo quale uso io: 7Zip, è open source, veloce e ha una versione a 64bit).

La distribuzione scompattata contiene le cartelle seguenti:

Contenuto della distribuzione
folder archetypes Può essere usato per generare una applicazione base RichFaces sfruttando Maven
folder artifacts Contiene le librerie RichFaces
folder docs Contiene il JavaDoc per RichFaces
folder examples Contiene la suite d’esempio

Per maggiori informazioni su come utilizzare Maven per configurare il proprio progetto consultare la guida Maven di JBoss.

Noi andremo a configurare manualmente il nostro progetto. Tutte le librerie aggiuntive di cui avremo bisogno sono:

Jar da aggiungere
jar richfaces-core-impl-4.0.0.Final.jar Richfaces core distribution
jar richfaces-core-api-4.0.0.Final.jar Richfaces core distribution
jar richfaces-components-ui-4.0.0.Final.jar Richfaces core distribution
jar richfaces-components-api-4.0.0.Final.jar Richfaces core distribution
jar sac-1.3.jar Interfaccia Standard per i Parser CSS
jar cssparser-0.9.5.jar CSS Parser
jar guava-r08.jar Google Core Libraries

Creiamo il progetto

Avviamo Eclipse, click su New –> Dynamic Web Project. Impostiamo le proprietà dello Wizard come di seguito, lasciando per le altre impostazioni il default:

rich4-03

Premendo su Finish vediamo che vengono creati due progetti:

  • HelloRichFaces4
  • HelloRichFaces4Ear

Aggiungiamo un pizzico di Facet

Facciamo click di destro sul progetto HelloRichFaces4 –> Properties –> Project Facets –> Check su JavaServer Faces 2.0.

rich4-04

Applicando il facet abbiamo ottenuto diverse cose:

  1. Eclipse sa che il nostro progetto utilizzerà le JSF (non avendo dato indicazioni di quale implementazione usare vengono usate le librerie incluse nel runtime di JBoss AS)
  2. Viene abilitato l’autocomplete nelle pagine web
  3. Vengono impostate alcune configurazioni nel file web.xml (il deployment descriptor dei moduli web) e creato il file faces-config.xml  (il file di configurazione di JSF)

Nella fattispecie i due file xml del punto 3 appariranno come segue:

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

  HelloRichFaces4
  
    Faces Servlet
    javax.faces.webapp.FacesServlet
    1
  
  
    Faces Servlet
    /faces/*
  

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


In pratica:

  • Nel web.xml viene definita la Faces Servlet e mappato un URL pattern affinché sia preso in carico dalla Servlet stessa.
  • Nel faces-config.xml viene soltanto stabilito che si intende utilizzare la specifica 2 di JSF.

Copiamo le librerie

Andiamo a copiare sotto WEB-INF/lib tutte le librerie che abbiamo sopra elencato, i 3 jar di terze parti e le 4 librerie RichFaces, che si trovano:

  • due sotto la cartella artifacts\framework (richfaces-core-api-4.0.0.Final e richfaces-core-impl-4.0.0.Final);
  • due sotto la cartella artifacts\ui (richfaces-components-api-4.0.0.Final e richfaces-components-ui-4.0.0.Final).

rich4-05

Adesso selezioniamo le 7 librerie, facciamo click di destro, selezioniamo Build Path –> Add to Build Path. Attendiamo qualche istante che Eclipse mescoli bene gli ingredienti.

La nostra prima pagina

La nostra pagina di Hello World! non si accontenta di salutare il mondo: creiamo un pannello dove l’utente possa:

  • Inserire il nome, la cui lunghezza deve essere compresa tra 3 e 12
  • Inserire la regione di residenza, operazione durante la quale viene assistito da un autocomplete

Ci serviranno una classe Java e un file xhtml.

Il managed bean

In una terrina rompiamo una nuova classe Java; per farlo consultiamo l’immagine di seguito:

rich4-06

Terminato di mescolare la classe sarà la seguente:

package it.cosenonjaviste.hellorichfaces4;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.faces.bean.ManagedBean;
import javax.validation.constraints.Size;

@ManagedBean
public class UserBean implements Serializable {
	@Size(min = 3, max = 12, message = "Must be between 3 and 12 chars")
	private String name;
	private String state;

	public String getName() {
		return name;	}

	public String getState() {
		return state;	}

	private List getRegioni() {
		List regioni = new ArrayList();
		regioni.add("Toscana");
		regioni.add("Liguria");
		regioni.add("Lombardia");
		regioni.add("Lazio");
		regioni.add("Sicilia");
		return regioni;	}

	public List autocomplete(String prefix) {
		List result = new ArrayList();
		List regioni = getRegioni();

		for (String regione : regioni) {
			if (regione.toLowerCase().startsWith(prefix.toLowerCase()))
				result.add(regione);
		}
		return result;
	}
}

Vi faccio notare che il backing bean implementa Serializable in quanto non possiamo escludere che questo codice prima o poi possa trovarsi su un application server in cluster e che il backing bean finisca in sessione come managed bean jsf. Per approfondimenti consultare Sviluppare Applicazioni (Java) Web Cluster Aware, Parte I e Parte II.

Chi conosce JSF 1.2 ma non JSF 2.0 sarà pieno di gioia nel notare che:

  • I backing bean possono diventare managed bean, ovvero essere gestiti da JSF, semplicemente annotandoli (annotation @ManagedBean, prima bisognava censirli nel faces-config.xml)
  • E possibile eseguire validazione a livello di bean (annotation @Size)

La bean validation è un nuovo modello di validazione (vedi JSR 303: Bean Validation) che fa parte della piattaforma Java EE 6 e supportato da JSF 2.0.

La pagina XHTML

Creiamo sotto la cartella WebContent una nuova pagina, hello.xhtml, e mettiamola nel microonde per 5-6 minuti. Alla fine dovrebbe contenere quanto segue:


 
 
 
 
   
     
     
        
     
     
     

Per cucinare la pagina ci vuole un server!

Creiamo una istanza di JBoss As

Nella vista Servers (se non è attiva Menu Windows -> Show View -> Servers per attivarla) facciamo click di destro, selezioniamo New -> Server. Accanto a Server Runtime Environment facciamo click su Add…. Impostiamo il puntamento alla cartella dove abbiamo scompattato JBoss AS quando lo abbiamo scaricato:

rich4-08

A questo punto possiamo selezionarlo:

rich4-07

Premendo Finish il server apparirà nella vista Servers.

Pronti per scolare la pasta?

Il modo più rapido che mi viene in mente per lanciare la nostra paginetta è fare click di destro sul file hello.xhtml -> Run as -> Run on Server. Selezioniamo il server che abbiamo creato prima:

rich4-09

Fatto! Le nostre RichFaces 4.x sono cucinate, sentite che profumino?! Per mangiarle digitiamo nel browser http://localhost:8080/HelloRichFaces4/faces/hello.xhtml.

rich4-10

Bon appetit!

Conclusioni

homer-droolIn questo breve post abbiamo condiviso una ricetta semplice ma gustosa in cui abbiamo fatto funzionare JBoss RichFaces 4.x su JBoss application server. Come abbiamo visto è stato molto semplice, ma ovviamente ci sono tante cose da dire sull’utilizzo di JSF, RichFaces e soprattutto sulla novella versione 4.0, che introduce tante interessanti novità. Nei prossimi post vedremo ricette più sofisticate che utilizzano gli stessi ingredienti, ad esempio salteremo in padella le differenze tra RichFaces 3.x e 4.x, cuoceremo Ajax senza farlo indurire etc etc. Restate con noi per scoprire nella prossima puntata tutti i segreti del JSF Lifecycle

Libri Consigliati

Manuele Piastra

Sono uno Scrum Master e Project Manager i cui skill tecnici sono focalizzati al momento sullo sviluppo di applicazioni Java EE su IBM Websphere 7.0 utilizzando JSF (RichFaces), JPA (EclipseLink) ed EJB3. Presso OmniaGroup ricopro il ruolo di Training Manager: seleziono il personale tecnico, mi occupo della sua crescita formativa organizzando Corsi e Workshop sia interni che esterni, molti dei quali hanno visto me come docente. LinkedIn Profile - Google+