CERCA SITEMAP FEED RSS 1280
Ultimo aggiornamento: 30 Agosto 2009

Backing bean in JavaServer Faces

In accordo con le specifiche JavaBeans:
Un Java Bean è un componente software riusabile
Nel contesto di JavaServer Faces, i beans sono spesso utilizzati per contenere alcuni dei componenti dell’interfaccia utente, pertanto prendono il nome di backing bean.
Una tipica applicazione JSF include uno o più backing bean associati a UIComponent usati all'interno di una pagina.
Tutti i bean, oltre a definire un costruttore senza argomenti, devono definire un insieme di proprietà dell'UIComponent e possibilmente un insieme di metodi di utilità.
Ogni proprietà di un bean può fare riferimento a:
  • valore di un componente
  • istanza di un componente
  • istanza di un convertitore
  • istanza di un listener
  • istanza di un validatore
Le funzioni più comuni che il metodo di un backing bean effettua sono:
  • la validazione dei dati del componente
  • la gestione di eventi
  • le elaborazioni necessarie per determinare la successiva pagina da visualizzare

Proprietà di un bean

Una proprietà di un bean è un attributo privato che ha un nome, un tipo e metodi get e set per accedervi.
Un bean deve avere un costruttore di default senza parametri e deve seguire opportune convenzioni nella definizione delle firme dei metodi get e set con i quali si accede alle proprietà dei bean.
I nomi dei metodi con i quali si accede alle proprietà di un bean devono iniziare obbligatoriamente con “get” e “set” seguiti dal nome della proprietà con la prima lettera maiuscola, il metodo get inoltre non deve avere parametri e il metodo set invece non deve restituire valori.
public class MioBean
{
  private int mia proprieta;

  public MioBean()
  {
  }

  int getMiaproprieta()
  {  
    return  miaproprieta;
  }
  
  void setMiaproprieta(int alore)
  {
    miaproprieta = valore;
  }
}
Le specifiche JavaBeans consentono anche di definire delle proprietà indicizzate.

Expression Language

Per collegare il valore di un componente alla proprietà di un bean o per fare riferimento ai metodi di un backing bean si utilizza l’Expression Language la cui sintassi è definita dalle specifiche JavaServer Pages 2.1

Alcune caratteristiche di tale linguaggio sono:
  • la possibilità di una valutazione differita delle espressioni
  • la possibilità di utilizzare un’espressione sia in lettura che in scrittura
  • la possibilità di utilizzare espressioni che fanno riferimento a metodi
La valutazione differita di un’espressione è importante perché il ciclo di vita di una pagina in JavaServer Faces è suddiviso in varie fasi e la gestione degli eventi, la validazione, la conversione e la propagazione dei dati sono effettuate in fasi differenti.
L’implementazione pertanto deve essere in grado di ritardare la valutazione delle espressioni finchè non viene raggiunta la fase appropriata del ciclo di vita: a tal proposito, gli attributi dei tag utilizzano sempre la sintassi differita attraverso il delimitatore #{}.
Per memorizzare dati in oggetti lato-server si fa uso di espressioni valore mentre per fare riferimento a metodi di oggetti lato-server si fa uso di espressioni metodo.
Nel seguente esempio l’attributo value contiene un’espressione valore che fa si che collega il valore del componente alla proprietà numero di gsbean, mentre l’attributo validator contiene un’espressione metodo che fa riferimento al metodo validate di gsbean che si occupa di validare i dati del componente.
  <h:inputText id="num" value="#{gsbean.numero}" validator="#{gs.validate}" />
Un altro uso delle espressioni valore è quello di collegare l’istanza di un componente alla proprietà di un bean facendo riferimento all’attributo binding del componente stesso.
  <h:inputText binding="#{gsbean.componente}" />

Collegare valori dei componenti ed istanze ai backing bean

Come visto, è possibile collegare i dati di un componente ad un backing beans in due modi:
  • attraverso l’attributo value che utilizza un’espressione valore che fa riferimento alla proprietà del bean
  • attraverso l’attributo binding che collega l’intera istanza dell’oggetto alla proprietà del backing bean che ovviamente deve essere dello stesso tipo.
Quando il valore di un componente viene collegato alla proprietà di un backing bean quest’ultima ne memorizza il valore che viene aggiornato durante la fase Update Model Values.
Naturalmente occorre assicurare una corrispondenza fra il tipo del valore del componente e il tipo della proprietà del bean.
In particolare:
  • il valore dei componenti UIInput, UIOutput, UISelectItem e UISelectOne può essere collegato a qualsiasi tipo primitivo o a qualsiasi oggetto per il quale sia disponibile l’appropriata implementazione del Converter.
  • il valore del componente UIData può essere collegato a array di beans, List of beans, single bean, java.sql.ResultSet, javax.servlet.jsp.jstl.sql.Result, javax.sql.RowSet
  • il valore del componente UISelectBoolean può essere collegato a boolean o Boolean
  • il valore di UISelectItems può essere collegato a java.land.String, Collaction, Array, Map
  • il valore di UISelectMany può essere collegato ad array o List di tipi standard.
Il vantaggio che deriva dal collegare direttamente l’istanza di un componente alla proprietà del bean è rappresentato dalla possibilità di modificare dinamicamente le proprietà del componente.
D’altra parte se si collega il valore del componente alla proprietà del bean si ottiene una completa separazione fra modello e presentazione.
In generare il collegamento fra istanza e proprietà del bean viene effettuato soltanto quando si ha la necessità di modificare gli attributi del componente dinamicamente.

Riferimenti ai metodi di un backing bean

Il riferimento ai metodi di un backing bean può avvenire sfruttando quattro distinti attributi:
  • action: viene utilizzato per fare riferimento al metodo di un backing bean che effettua alcune elaborazioni necessarie per stabilire quale pagina caricare successivamente e restituisce un valore logico.
  • actionListener: fa riferimento a un metodo di un backing bean che gestisce un action event
  • validator: fa riferimento a un metodo di un backing bean che effettua un’operazione di validazione sui dati di un componente
  • valueChangeListener: fa riferimento a un metodo di un backing bean che gestisce un value-change event
Naturalmente soltanto i componenti che implementano l’interfaccia ActionSource possono fare uso dell’attributo action così come solo i componenti che implementano l’interfaccia EditableValueHolder possono usare gli attributi validator e valueChangeListener.
I metodi referenziati da tali attributi devono avere una particolare firma definita nel corrispondente Tag Library Descriptor.

Configurazione dei bean

La configurazione di un bean avviene nel file di configurazione dell’applicazione facendo uso dell’elemento xml managed-bean come nel seguente esempio:
<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>
L’elemento managed-bean definisce la configurazione di un bean che ha il nome definito dall’elemento managed-bean-name, è istanza della classe definita dall’elemento managed-bean-class e ha scope (visibilità) definito dall’elemento managed-bean-scope.
L’elemento managed-property definisce la proprietà del bean che ha nome definito dall’elemento property-name, è istanza della classe definita dall’elemento property-class e ha valore iniziale definito dall’elemento value.
Se si vuole definire un valore iniziale null si può usare l’elemento <null-value/> Per inizializzare i valori di una proprietà di tipo List si utilizza l’elemento list-entries specificando la classe degli elementi della lista mediante l’elemento value-class e i valori degli elementi mediante l’elemento value
<managed-bean>
   <managed-bean-name>miobean2</managed-bean-name>
   <managed-bean-class>miopackage.MioBean2</managed-bean-class>
   <managed-bean-scope>session</managed-bean-scope>
   <managed-property>
     <property-name>selezionati</property-name>
     <list-entries>
       <value-class>int</value-class>
       <value>0 </value>
       <value>3</value>
       <value>5</value>
       <value>8</value>
       <value>12</value>
     </list-entries>
  </managed-property>
</managed-bean>
Per inizializzare i valori di una proprietà di tipo Map invece si fa uso di un elemento map-entries, specificando con key-class e value-class (di default String) la classe della chiave e dei valori e definendo con map-entry ogni associazione all’interno della mappa chiave (elemento key) – valore (elemento value).
<map-entries>
  <key-class>java.lang.Integer</key-class>
  <map-entry>
    <key>1</key>
    <value>Marco Rossi</value>
  </map-entry>
  <map-entry>
    <key>3</key>
    <value>Mara Verdi</value>
  </map-entry>
  <map-entry>
    <key>5</key>
    <value>Paolo Rossi</value>
  </map-entry>
</map-entries>