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

JSP: Panoramica sugli Action Elements

Una descrizione approfondita degli elementi di azione per usare i bean
Una descrizione approfondita degli elementi di azione per usare i bean
Link copiato negli appunti

Come è noto, i tag che è possibile utilizzare in una pagina JSP, possono essere raggruppati in tre categorie:

  • Directive elements
  • Scripting elements
  • Action Elements

Ci occuperemo, in questo articolo, degli Action Elements (già menzionati nella guida JSP) cercando di mettere in risalto, in particolare, le peculiarità dei tag più importanti.

Gli Action Elements (Elementi di Azione), anche conosciuti come Standard Actions, sono definiti nelle specifiche JSP. In particolare, nello standard JSP 2.0, sono previsti i seguenti elementi:

  • <jsp:useBean>
  • <jsp:setProperty>
  • <jsp:getProperty>
  • <jsp:include>
  • <isp:forward>
  • <jsp:param>
  • <jsp:plugin>
  • <jsp:params>
  • <jsp:fallback>
  • <jsp:attribute>
  • <jsp:body>
  • <jsp:invoke>
  • <jsp:doBody>

Gli ultimi due sono rappresentati in grigio in quanto verranno descritti in un prossimo articolo, quando parleremo di tag libraries.

L'azione <jsp:useBean>

Il compito di questo elemento è quello di rendere disponibile un Java Bean alla pagina JSP in cui il tag stesso è utilizzato. Un Java Bean, per rinfrescarci la memoria, non è assolutamente da confondere con gli Enterprise Java Beans (EJB) ma è, più semplicemente, una classe Java che soddisfa determinati requisiti. In particolare:

  • Deve avere un costruttore senza parametri
  • Ogni proprietà del bean che si desidera rendere visibile a livello client, deve avere un metodo per impostare il valore della proprietà ed un altro per ricavarne il valore stesso.

La forma di questi metodi è la seguente:

public tipo getMyBeanProperty() { return myBeanProperty; }
public void setMyBeanProperty (tipo myBeanProperty)
{
  // Imposta il valore della proprietà con tipo tipo
}

È importante che ogni metodo "setter" (quello che imposta il valore) e "getter" (quello che ricava il valore) utilizzi il nome della proprietà del bean con la prima lettera in maiuscolo subito a seguire il suffisso set o get. Inoltre, il metodo getter assume una connotazione diversa quando si ha a che fare con proprietà di tipo boolean. Eccone il formato:

public boolean isMyBeanProperty() { return aBooleanParameter; }

Vediamo adesso gli attributi dell'action element <jsp:useBean>:

  • id: Il nome utilizzato per accedere al Java Bean dalla pagina JSP. Deve essere unico. Fondamentalmente, rappresenta il nome della variabile che fa riferimento all'istanza del Java Bean
  • scope: Lo scope del bean, ovvero il suo livello di visibilità. Valori possibili sono: page, request, session e application. Il valore di default è page.
  • class: Il nome della classe di cui il bean rappresenta un'istanza.
  • beanName: Il nome di un bean, cui può far riferimento il metodo instantiate() della classe java.beans.Beans. Nella maggior parte dei casi verrà, comunque, utilizzato l'attributo class al posto del beanName. Per maggiori informazioni su come fornire un beanName al metodo instantiate(), si consiglia di visitare questo link.
  • type: Il tipo da utilizzare per la variabile che referenzia il bean. Naturalmente, è possibile avvantaggiarsi delle regole dell'Object Oriented (del polimorfismo, in tal caso) ed utilizzare, a tal fine: la classe cui appartiene l'istanza del bean, qualunque classe antenata della classe del bean o, ancora, eventuali interfacce implementate dal bean o da una sua classe padre.

Il tag <jsp:useBean> indica al web container di cercare di trovare un'istanza esistente del bean utilizzando lo scope e l'id specificati. Se, con tali informazioni, non viene trovato alcun oggetto, ma è stata fornito il nome di una classe (attraverso l'attributo class) o il nome di un bean (attraverso l'attributo beanName) , il container tenterà di creare una nuova istanza del bean.

È possibile utilizzare gli attributi class, beanName e type avvalendosi delle seguenti possibili combinazioni:

  • class – Crea un'istanza della classe indicata dall'attributo class. Tale istanza può, quindi, essere referenziata utilizzando l'id fornito.
  • class, type – Crea un'istanza della classe indicata dall'attributo class. La variabile che referenzia il bean avrà il tipo indicato dall'attributo type.
  • beanName, type – Crea un'istanza del bean indicato dall'attributo beanName. La variabile che referenzia il bean avrà il tipo indicato dall'attributo type.
  • type – Se un oggetto del tipo indicato dall'attributo type esiste nella sessione, l'id farà riferimento a tale oggetto.

Naturalmente, l'utlilizzo dell'action <jsp:useBean> rappresenta la condizione necessaria affinché possano essere utilizzati gli altri action elements riguardanti i Java Beans (di cui parleremo subito a seguire), ovvero: <jsp:setProperty> e <jsp:getProperty>.

L'azione <jsp:setProperty>

Lo scopo di questo elemento è valorizzare una proprietà di un Java Bean. Gli attributi ad esso associati sono i seguenti:

  • name: L'id del bean
  • property: Il nome della proprietà da valorizzare. Può essere fornito un nome ben preciso, corrispondente ad una singola proprietà del bean, nel qual caso verrà automaticamente invocato il metodo setXXX() della proprietà in questione. Alternativamente, è possibile impostare l'attributo property con il valore "‘*" (senza doppi apici). In tal caso, la pagina JSP leggerà tutti i parametri che sono stati inviati attraverso il browser (su richiesta del client) e imposterà tutte le proprietà del bean che trovano un nome corrispondente in uno dei parametri della richiesta.
  • param: Il nome del parametro, utilizzato nella richiesta effettuata via browser, che verrà utilizzato per impostare la proprietà del bean
  • value: Il valore da assegnare alla proprietà del bean

Gli attributi name e property devono essere sempre presenti quando si utilizza l'action element <jsp:setProperty>. Invece, param e value sono mutuamente esclusivi (se ne viene utilizzato uno non può essere utilizzato l'altro).

L'azione <jsp:getProperty>

Attraverso questo action element è possibile ricavare il valore di una proprietà di un Java Bean. Gli attributi utilizzabili sono i seguenti:

  • name: L'id del bean
  • property: il nome della proprietà di cui si vuole ricavare il valore

Entrambi gli attributi (name e property) sono sempre obbligatori.

Vediamo adesso un semplice esempio (uno spezzone di codice) che riassuma l'uso degli action elements fin qui descritti. Si supponga di aver definito il seguente Java Bean, contenente delle informazioni relative agli utenti utilizzatori di un sistema:

Listato 1. Esempio di Java Bean

public class SystemUser
{
  private String userID;
  private String userName;

  public void setUserID(String id)
  {
    this.userID = id;
  }

  public String getUserID ()
  {
    return userID;
  }

  public void setUserName(String name)
  {
    this.userName = name;
  }

  public String getUserName ()
  {
    return userName;
  }
}

Per interagire con il nostro Bean, attraverso gli action elements descritti, potremo utilizzare il seguente codice all'interno di una pagina JSP:

Listato 2. Pagina JSP che usa il Bean

<jsp:useBean id="user_A" class ="SystemUser" />
<jsp:setProperty name="user_A" property="userName" value="Marco" />
<jsp:setProperty name="user_A" property="userID"
      value =<%= checkID("4321") %>" />

L'utente con userID <jsp:getProperty name="user_A"
    property="userID" /> si chiama <jsp:getProperty name="user_A"
    property="userName" />

L'azione <jsp:include>

Diciamo subito che c'è un'importante differenza tra la direttiva di include (directive element) la cui sintassi è:

<jsp:directive.include file="nomefile" />

e l'action element <jsp:include>. La differenza è basata sul momento in cui una determinata risorsa viene inclusa in una pagina JSP e su come tale inclusione avviene.

Infatti, l'uso del "directive element" causa l'inclusione della risorsa indicata dall'attributo file, nel momento stesso in cui il container JSP traduce la pagina. Il file referenziato diviene, in pratica, parte integrante del sorgente che costituisce la classe di implementazione della pagina JSP e il codice di tale file viene inserito nello stesso punto in cui si è fatto ricorso alla direttiva di include. Oltretutto, il file inserito tramite la direttiva di include non necessita di essere una pagina JSP valida e completa.

Diversa la situazione per l'azione di include. In questo caso, il file JSP interrompe il processamento della richiesta corrente e trasferisce la richiesta stessa al file da includere. Quest'ultimo, quindi, trasmette il proprio output all'oggetto response e poi restituisce il controllo della response stessa alla pagina JSP chiamante (quella contenente l'action element) la quale, infine, completa la costruzione della risposta da fornire al client.
In questo caso, diversamente da quanto puntualizzato per il directive element, le risorse che sono incluse nel tag dell'azione devono essere, a loro volta, valide pagine JSP (o servlet).

Gli attributi utilizzabili sono i seguenti:

  • page: La URL della pagina il cui output è inserito nell'oggetto response
  • flush: Indica se il buffer di output deve essere "ripulito" (flushed) prima che venga incluso il file indicato nell'attributo page. Il valore di default è false.

Solo l'attributo page è obbligatorio. Il formato da utilizzare per l'azione di include è il seguente:

<jsp:include page="URL_Pagina" flush="true|false" />

L'azione <jsp:forward>

Quando si utilizza questo tipo di azione, la pagina corrente interrompe il processamento della richiesta pervenutagli e inoltra la richiesta stessa (tramite l'oggetto request) ad un altro componente web. Quest'ultimo si occuperà di scrivere e completare la risposta (response) senza più restituire (diversamente da quanto visto nel precedente action element) il controllo alla pagina chiamante.

C'è una ulteriore differenza importante da mettere in risalto tra l'azione <jsp:forward> e l'azione <jsp:include>. La seconda può avvenire in qualunque istante durante la costruzione della risposta mentre la prima deve necessariamente verificarsi prima che venga scritto qualunque output attraverso l'oggetto OutputStream.

L'unico attributo utilizzabile è:

  • page: indica la URL della pagina a cui eseguire l'azione di inoltro.

Il formato da utilizzare per l'azione di forward è, dunque, il seguente:

<jsp:forward page="URL_Pagina" />

L'azione <jsp:param>

Nel caso in cui una pagina JSP abbia la necessità di passare dei parametri ai componenti referenziati dalle azioni <jsp:include> e <jsp:forward>, sarà necessario utilizzare l'action element <jsp:param> tante volte quanti sono i parametri da far viaggiare. Gli attributi di questo action element sono:

  • name: Il nome del parametro
  • value: Il valore associato al parametro di nome name

Entrambi gli attributi sono sempre obbligatori. Vediamo, di seguito la modalità di utilizzo di questo tag:

<jsp:include page="URL_Pagina" flush="true|false" >
    <jsp:param name="nomeParametro" value="valoreParametro" />
</jsp:include>

E nel caso di foward:

<jsp:forward page="URL_Pagina">
    <jsp:param name="nomeParametro" value="valoreParametro" />
</jsp:forward>

Nella parte successiva dell'aticolo esamineremo gli elementi di azione rimanenti

Continua la carrellata sugli Action Elements iniziata nella parte precedente dell'articolo.

L'azione <jsp:plugin>

Attraverso questo elemento è possibile scaricare sul browser un plugin che consente di eseguire un Applet o un particolare Bean. Gli attributi utilizzabili sono:

  • type: indica se si tratta di un bean o di un Applet. Infatti i suoi possibili valori sono: bean, applet
  • code: il nome della classe Java utilizzata dal plugin
  • codebase: il percorso assoluto o relativo da utilizzare per arrivare al codice indicato nell'attributo code. Se non si fornisce un valore per tale attributo, viene usato, per default, il path della pagina JSP contenente l'action element
  • name: il nome assegnato all'istanza del bean o dell'applet
  • archive: uno o più file di archivio (tipicamente .zip, .jar) da precaricare prima di eseguire l'applet o il bean
  • align: l'allineamento del riquadro rappresentante l'applet o il bean all'interno della pagina JSP, relativamente al testo circostante. Può avere uno dei seguenti valori: bottom, top, middle, left, right
  • height: l'altezza iniziale, in pixel, dell'immagine visualizzata dall'applet o dal bean
  • width: la larghezza iniziale, in pixel, dell'immagine visualizzata dall'applet o dal bean
  • hspace: uno spazio aggiuntivo, in pixel, a destra e a sinistra da aggiungere all'immagine visualizzata dall'applet o dal bean
  • vspace: uno spazio aggiuntivo, in pixel, in alto e in basso da aggiungere all'immagine visualizzata dall'applet o dal bean
  • jreversion: la versione del JRE (Java Runtime Environment) richiesto dal bean o dall'applet per essere eseguito correttamente
  • nspluginurl: la URL da utilizzare per scaricare il plugin JRE per il browser Netscape Navigator
  • iepluginurl: la URL da utilizzare per scaricare il plugin JRE per il browser Internet Explorer

Soltanto i primi tre attributi (type, code e codebase) sono obbligatori. Vediamo un esempio:

<jsp:plugin type=applet code="myapplet.class" codebase="/myfolder" />

L'azione <jsp:params>

Questo action element deve essere utilizzato (quando necessario) all'interno dell'azione <jsp:plugin> e consente di passare eventuali parametri all'applet o al bean utilizzato.

Ogni singolo parametro, a sua volta, dovrà essere impostato utilizzando l'action element <jsp:param> (già descritto in precedenza), annidato all'interno del tag <jsp:params>. Un esempio aiuterà a capire meglio:

<jsp:plugin type=applet code="myapplet.class" codebase="/myfolder">
    <jsp:params>
      <jsp:param name="primopar" value="valore1" />
      <jsp:param name="secondopar" value="valore2" />
    </jsp:params>
</jsp:plugin>

L'azione <jsp:fallback>

Come il precedente action element, anche jsp:fallback può essere utilizzato all'interno dell'azione <jsp:plugin> e consente di impostare un messaggio da visualizzare qualora l'applet o il bean richiesto non possa essere caricato con successo.

Nessun attributo è definito per questo action element. Vediamo come utilizzarlo:

<jsp:plugin type=applet code="myapplet.class" codebase="/myfolder">
    <jsp:params>
        <jsp:param name="primopar" value="valore1" />
        <jsp:param name="secondopar" value="valore2" />
    </jsp:params>
    <jsp:fallback>
        <p>Impossibile caricare l'applet</p>
    </jsp:fallback>
</jsp:plugin>

L'azione <jsp:attribute>

Tutte le standard actions e le custom actions possono utilizzare al loro interno un'azione <jsp:attribute> come sostituto per uno degli attributi previsti al loro interno. Questo stratagemma si rivela particolarmente utile quando il valore di un attributo richiede un'espressione composta da più righe di dati espresse in XML.

Gli attributi di <jsp:attribute> sono:

  • name: il nome dell'attributo da sostituire
  • trim: indica se deve essere effettuata una rimozione degli spazi (blank) prima e dopo il body dell'elemento. I valori possibili sono true e false ed il valore di default, qualora tale attributo non venga utilizzato, è true
  • L'unico attributo obbligatorio è name. Vediamo un esempio che utilizza questo action element:

    <jsp:include>
        <jsp:attribute name="page">mypage.jsp</jsp:attribute>
    </jsp:include>

    che è equivalente a scrivere:

    <jsp:include page=" mypage.jsp "/>

    L'azione <jsp:body>

    L'action element <jsp:body> viene utilizzato per specificare il contenuto localizzato tra il tag di apertura e quello di chiusura di un altro action element. Tale contenuto è detto body content di un tag.
    Per rendere l'idea, in modo generico:

    <jsp:genericTag>questo è il body content</jsp:genericTag>

    Ed utilizzando l'azione <jsp:body> l'istruzione precedente può essere espressa:

    <jsp:genericTag>
        <jsp:body>questo è il body content</jsp:body>
    </jsp:genericTag>

    L'utilizzo di <jsp:body> diviene necessario quando si ha la necessità di inserire un body content pur avendo già utilizzato, all'interno dello stesso tag, l'action element <jsp:attribute>. Infatti, utilizzando quest'ultima azione, verrebbe assunto per default che non vi sia alcun body content. Intervenendo, allora, con <jsp:body>, si risolve il problema.

    Un esempio servirà a chiarire meglio il concetto:

    <jsp:genericTag>
        <jsp:attribute name="myAttribute">valore</jsp:attribute>
        <jsp:body>questo è il body content</jsp:body>
    <jsp:genericTag>


    Ti consigliamo anche