Il 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

Prima 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 , 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

Ora 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

	archetypes	Può essere usato per generare una applicazione base RichFaces sfruttando Maven
	artifacts	Contiene le librerie RichFaces
	docs	Contiene il JavaDoc per RichFaces
	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

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

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:

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.

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

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:

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, e .

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:

A questo punto possiamo selezionarlo:

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:

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

Bon appetit!

Conclusioni

In 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

Libri Consigliati