Embed Size (px)
Citation preview
Struts
Struts
Framework open source per lo sviluppo di applicazioni web su piattaforma J2EE.
Progetto inizialmente sviluppato come sotto-progetto di Apache Jakarta ma ora è divenuto un progetto a sé.
Struts estende le Java Servlet, aiutando all'utilizzo del pattern Model-View-Controller
Ideatoda Craig McClanahan donato alla Apache Software Foundation nel maggio del 2000.
Struts
Framework (infrastruttura) è una struttura di supporto su cui un software può essere organizzato e progettato. Ha le seguenti caratteristiche
Risparmiare allo sviluppatore la riscrittura di codice già steso in precedenza per compiti simili
Si estendono le classi del framerwork e/o se ne implementano le interfacce; sono i componenti del framework che hanno la responsabilità di controllare il flusso elaborativo.
sono le classi del framework che invocano il nostro codice applicativo e non viceversa come nel caso delle librerie di classi
Utilizza i design pattern
Una libreria contiene funzioni o routine (metodi) che l’applicazione può invocare
Framework fornisce componenti generici che collaborano tra loro che possono essere estesi (punti di estensione) per fornire nuove funzionalità
Vantaggi di un framework
1. Disegno architetturaleUn framework è fondato su un disegno architetturale valido, in quanto il suo codice è scritto in base alle best-practices della tecnologia in uso.
2. Riduzione dei tempi di progettoLo sviluppatore deve implementare esclusivamente la logica applicativa potendo risparmiare le energie e il tempo necessari alla scrittura di componenti infrastrutturali.
Semplificazione dello sviluppoSemplifica lo sviluppo applicativo perché fornisce tutta una serie di componenti che risolvono la gran parte dei compiti comuni a tutte le applicazioni web J2EE (controllo del flusso, logging, gestione messaggi di errore, custom tags per la presentation logic, internazionalizzazione, validazione dei dati, etc..)
Scelta del Framework1. Maturità del progetto
Sconsigliabile adottare un framework che sia in una fase iniziale di sviluppo e che sia poco adottato nella comunità degli sviluppatori e quindi poco testato sul campo in progetti reali.
2. DocumentazioneVerificare che la documentazione sia ricca e ben fatta. Questo facilita la risoluzione dei problemi che si incontrano nella realizzazione dell'applicazione e la comprensione del suo funzionamento.
3. Validità del disegno architetturale Verificare che sia disegnato correttamente e quindi che siano adottati i design-pattern e le best-practises della tecnologia di riferimento.
Adozione degli standardUn framework deve essere fondato sui componenti standard della tecnologia di riferimento. Evitare framework conuso di specifici tool di sviluppo o un modello troppo indirizzato ad uno specifico caso applicativo
EstensibilitàDeve essere possibile estenderne le funzionalità per adattarlo alle alle proprie esigenze.
Web application: Modello 1
Browser
Web / Servlet Container
JSPJava
Beans
Richiestadell’utente
Rispostadel sistema
DB
Pattern Model-View-Controller
Controller
Business ModelUtenteUtente
Azione Modifica stato
View
Scelta rappresentazione
dello stato
Notifica variazionedello stato
Web application: Modello 2
Browser
Web / Servlet Container
JSP
Richiesta
Risposta
Servlet
dispatch
BusinessModel
Struts e Modello 2
Client
Web / Servlet Container
view
Richiesta
Risposta
Servlet
dispatch
BusinessModel
Servlet
Struts
Extension point
I componenti di Struts
ActionServlet: servlet di controllo che gestisce tutte le richieste dell'applicazione; estende la classe javax.servlet.http.HttppServlet e quindi implementa tutti i metodi di lifecycle, incluso init(), doGet(), doPost() ed il destroy.
struts-config.xml: cuore di tutta l'applicazione. In tale file XML si vanno a settare ed a definire i vari elementi della nostra applicazione e le loro associazioni. Tale file viene letto in fase di start-up dell'applicazione dalla ActionServlet.
Action: Le Action sono le classi alle quali le ActionServlet delega l'elaborazione della richiesta.
ActionMapping: Contiene gli oggetti associati ad una Action nello struts-config come ad esempio gli ActionForward.
ActionForm: Sono dei veri contenitori di dati. Fanno riferimento ad uno specifico form e vengono popolati automaticamente dal framework con i dati contenuti nella request http.
ActionForward: Contengono i path ai quali la servlet di Struts inoltra il flusso in base alla logica dell'applicazione.
Custom-tags: Sono tag particolari forniti dal framework Struts per assolvere a molti dei più comuni compiti delle pagine JSP.
Caratteristiche di Struts
1. DP FrontController :Esiste una sola servlet di controllo centralizzata e tutte le richieste sono mappate sulla ActionServlet nel web.xml dell'applicazione. Unico punto di gestione del flusso applicativo permette di implementare in modo univoco e centralizzato funzioni quali sicurezza, logging, filtri etc.
2. I livelli logici dell'applicazione sono disaccoppiati. Le viste dell'applicazione non contengono al loro interno il riferimento al flusso dell'applicazione e non contengono logica applicativa.
3. Le viste sono mappate con nomi logici definiti nel file di configurazione struts-config.xml. Nel codice Java non è presente alcun riferimento a nomi di pagine JSP il che rende molto più semplice variare il flusso applicativo.
4. Configurazione dell'applicazione in un file XML: consente di modificare le associazioni tra le richieste http e le classi ad essa associate in modo molto semplice.
Controller e Model in Struts
Struts è un framework model-neutral, ovvero che implementa esclusivamente i livelli di controller e view.
E’ possibile realizzare il livello di business logic in base alle proprie scelte
con semplici classi Java DAO (quindi implementando la logica applicativa nel web-container)
ricorrendo agli EJB quindi sfruttando i servizi del EJB-container
ActionServlet e RequestProcessor
org.apache.struts.action.ActionServlet è la servlet di controllo di Struts: gestisce tutte le richieste http che provengono dai client e indirizza il flusso applicativo in base alla configurazione presente nel file XML struts-config.xml.
estende la javax.servlet.http.HttpServlet; i suoi metodi doGet() e doPost() chiamano entrambi un metodo process()
La ActionServlet esegue l'elaborazione che prevede:
1. I metodi doGet() e doPost() invocano il metodo process() della ActionServlet
2. Nel process() la ActionServlet ottiene l'istanza del RequestProcessor, configurato per l'applicazione nel tag <controller> dello struts.config.xml, e ne esegue il metodo process().
3. Nel metodo process() del RequestProcessor viene eseguita l'elaborazione vera e propria, ed in output al metodo viene fornito un oggetto ActionForward che consente alla ActionServlet di inoltrare l'elaborazione in base alla configurazione presente nello struts-config.xml.
ActionServlet e RequestProcessor
<!-Configurazione standard della Action Servlet --><servlet><servlet-name>action</servlet-name><servlet-class>org.apache.struts.action.ActionServlet</servlet-class><init-param><param-name>config</param-name><param-value>/WEB-INF/struts-config.xml</param-value></init-param><init-param><param-name>debug</param-name><param-value>2</param-value></init-param><load-on-startup>1</load-on-startup></servlet> <!- Mapping della Action Servlet --><servlet-mapping><servlet-name>action</servlet-name><url-pattern>*. do</url-pattern></servlet-mapping>
ActionServlet e RequestProcessor
la org.apache.struts.action.RequestProcessor è la classe alla quale la ActionServlet delega l'elaborazione delle richieste.
RequestProcessor viene configurato mediante il tag <controller> dello struts-config.xml
E’ possibile utilizzarne uno proprio scrivendo una classe che estende la org.apache.struts.action.RequestProcessor e ne implementa i metodi
Di uso comune fare l'override del metodo processPreprocess() che viene eseguito dal RequestProcessor prima dell'elaborazione di ogni richiesta. Punto ottimale per inserire controlli di validità della sessione, dell'utente o simili.
ActionServlet e RequestProcessor
Il RequestProcessor esegue i seguenti step:
1. Legge il file struts-config.xml per trovate un un elemento XML <action> corrispondente al path della richiesta.
2. Trovato l'elemento <action> verifica se è presente l'attributo name che corrisponde al nome dell'ActionForm. Reperire una istanza dell'ActionForm e ne popola gli attributi con i valori presenti nella request http, facendo una corrispondenza tra nome parametro e nome attributo.
3. Se nell'elemento <action> è presente l'attributo validate al valore true chiama il metodo validate() dell'ActionForm per il controllo dei dati forniti dalla request.
4. Se il controllo è ok a questo punto il RequestProcessor chiama il metodo execute() dell'Action configurata nell'elemento <action> delegandole l'elaborazione della richiesta.
5. Il metodo execute() dell'Action al termine dell'elaborazione restituisce un oggetto ActionForward che consente al RequestProcessor di inoltrare il flusso elaborativo.
Struts-config
<!-definizione del ActionForm --><form-beans> <form-bean name="startForm" type="it.prove..MenuForm" /></form-beans>
<action-mappings><!-definizione del Action --><action path="/start“input=“start.jsp” name="startForm" scope="request" type="it.prove.StartAction" validate="true"> <forward name="ok" path="/pagina1.jsp"/> <forward name="ko" path="/errorpage.jsp"/> </action></action-mappings>
Classe Action
La classe Action :creare una propria classe che la estende e ne implementa il metodo execute()
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception{
Il metodo execute() riceve in input request e response http, un'istanzadell'oggetto ActionForm prima descritto, e un oggetto ActionMapping che contiene le infornazioni configurate nell'elemento <action> tra le quali i forward, ovvero i percorsi a cui inoltrare in uscita l'elaborazione.
Restituisce un oggetto ActionForward che contiene il path di inoltro dell'elaborazione.
Classe Action
Le Action costituiscono il 'ponte' applicativo tra lo strato di Controller e di Model di un aapplicazione scritta con Struts
Le Action vengono gestite come delle servlet logica multithread delle servlet codice scritto nelle Action deve essere thread-safe per un corretto funzionamento delle stesse.
Le Action fanno parte del Controller e non del Model. La logica applicativa non deve essere scritta nella Action, ma questa deve delegare allo strato di Model l'elaborazione della business-logic.
Classe Action
Compiti della Action
Acquisire i dati della request dal form
Delegare l'elaborazione della business-logic alle classi del Model
Acquisire i risultati dell'elaborazione e prepararli per la vista da inviare all'utente mettendoli nello scope opportuno (se necessario).
Inoltrare il flusso elaborativo in base alla logica applicativa.
Classi Action Pronte
ForwardActionquando è necessario fare il forward da una pagina jsp a un’altra senza bisogno di passare per un’Action
<action input="/index.jsp" name=“loginForm" path=“/viewLogin" parameter=“/sevurity/signin.jsp”type=“org.apache.struts.actions.ForwardAction" validate=“false"> </action>
Classi Action Pronte
DispatchActionconsentire che risiedano su una singola classe operazioni multiple
<action path=“/cart" input="/order/shoppingcart.jsp" parameter=“method”name=“loginForm" type=“org.apache.struts.actions.EstendiDispatchAction" validate=“false"> <forward name=“....” path=“....”
</action>
Classi Action Pronte
LookupDispatchActionconsentire di invocare metodi multipli invocati sulla base del valore di uno speciale parametro di request indicato nel file di configurazione. Viene fatto poi un reverseLookup sul resourse bundle.
Occorre creare una classe che estenda LookupDispatchAction e implementi il metodo getKeyMethodMap()
Protected Map getKeyMethodMap(){Map map= new HashMap();map.put(“button.checkout”,”checkout”); map.put(“button.saveorder”,” saveorder”);}
Nel resource bundle si ha:button.checkout= Checkout button.saveorder= Save Order
Classi Action pronte
<action path=“/processcheckout" input="/checkout.jsp" name=“checkoutForm“parameter=“action”scope=“request”type=“...ProcessCheckoutAction" > <forward name=“....” path=“....”
</action>
Nella Jsp
<html:form action=“/processcheckout”><html:submit property=“action”><bean:message key=“button.checkout” /></html:submit></html:form>
ActionForm
org.apache.struts.action.ActionForm. I form (come sono chiamate nella terminologia Struts le classi che estendono la org.apache.struts.action.ActionForm) sono sostanzialmente dei bean contenenti dati, che il framework popola automaticamente con i dati della request svincolando lo sviluppatore dal doverlo fare con proprio codice applicativo
la struttura è esattamente quella di un JavaBean a parte l'estensione della classe ActionForm
hanno attributi privati e corrispondenti metodi get e set pubblici. due metodi particolari: reset() e validate()
ActionForm
public ActionErrors validate(ActionMappings mapping,HttpServletRequest request) Il tipo di ritorno del metodo è un oggetto della classe ActionErrors che è un contenitore di oggetti della classeorg.apache.struts.action.ActionError Ogni oggetto della classe ActionError rappresenta un errore verificatosi nella validazione dei dati
Con un opportuno custom tag (<html:errors>) posto nella pagina stessa sarà possibile visualizzare i messaggi di errore associati agli errori verificatisi senza scrittura di codice aggiuntivo.Il messaggio di errore viene reperito automaticamente dal framework dal resouce bundle dell'applicazione
ActionErrors errors = new ActionErrors();
if ((username == null) || (username.length() < 1)) errors.add ("username",new ActionError("errore.username.obbligatorio")); return errors; }
Sezioni global
<global-exceptions> <exception key="label.eccezione" type="it.esempi.MiaException" handler="it.esempi.ExceptionHandler"/></global-exceptions>
<global-forwards> <forward name=“SystemFailure" path=“/systemerror.jsp"/> <forward name=“SystemFailure" path=“/sessiontimeout.jsp"/></global-forwards>
Librerie custom-tag
1. html Tag per la generazione di form HTML che interagiscono con gli ActionForm e degli altri elementi HTML di una pagina JSP
2. bean Tag usati per accedere a proprietà di JavaBeans e per creare istanze di bean
3. logic Tag usati per logica condizionale, iterazioni e controllo di flusso
4. Template
5. nested Tag che estendono le funzionalità dei tag base
Librerie di tag <html:form action="/login" >
<TABLE><TR><TH>Username:</TH><TD><html:text property="username"/></TD></TR><TR><TH>Password:</TH><TD><html:password property="password"/></TD></TR><TR><TD><html:submit/></TD></TR></TABLE></html:form>
Nella libreria logic esistono numerosi tag per eseguire logica condizionale quali <logic:empty> <logic:notEmpty> <logic:equal> <logic:notEqual> <logic:greaterThan> ed altri., tag per eseguire iterazioni su array e collection quali <logic:iterate>, e tag per eseguire controllo di flusso come il <logic:redirect>.
Nella libreria bean sono presenti tag per la definizione di variabili di scripting utilizzabili all'interno della pagina quali <bean:define> , tag per la scrittura in output del valore di attributi di un <bean: write> e così via.
Gestione delle eccezioni
I due approcci possibili nella gestione delle situazioni di eccezione, così come nella gestione di molte altre problematiche sono quello programmatico e quello dichiarativo.
l'approccio programmatico consiste nello scrivere all'interno della propria applicazione codice specifico per la gestione di una determinata problematica
l'approccio dichiarativo consiste nel configurare all'esterno dell'applicazione le modalità di gestione del problema stesso
Gestione delle eccezioni
Una Action contenente gestione programmatica delle eccezioni potrebbe avere un aspetto simile:
try{ //codice che può generare eccezioni}catch(Exception e){ ActionErrors errors = new ActionErrors(); erorrs.add("eccezione", new ActionErorrs("eccezione")); saveErrors(request,errors); return mapping.findForward("eccezione"); }
costringe comunque lo sviluppatore a scrivere codice ad hoc, spesso ridondante, per gestire queste situazioni.
Se si vuole modificare il comportamento dell'applicazione al verificarsi di una eccezione è necessario intervenire nel codice.
Gestione delle eccezioni
Più elegante ed efficiente sfruttare la possibilità offerta da Struts di gestire in modo dichiarativo le eccezioni nel file XML di configurazione struts-config.xml, è possibile descrivere mediante opportune sezioni XML il comportamento che l'applicazione deve avere a fronte di una particolare eccezione
può essere fatta a livello di singola Action o a livello globale per tutta l'applicazione.
Per configurare la gestione a livello di singola action si utilizza il tag <exception> all'interno della configurazione della Action stessa.
Gestione delle eccezioni
Nel tag <exception> si dichiara la classe dell'eccezione da gestire, la risorsa a cui verrà inoltrato il flusso elaborativo ed una chiave per acquisire dal resource bundle dell'applicazione un messaggio di errore
<action path"/esempio" type="it.esempi.EsempioAction" input="input.jsp" scope="request" name="myForm" > <exception key="label.eccezione.esempio" type="it.esempi.MiaException" path="errorpage.jsp" /></action>
Gestione delle eccezioni
E' anche possibile definire un comportamento globale utilizzando il tag <global-exception>. In tal caso si presuppone la definizione di una o più classi handler per le eccezioni da gestire, ovvero delle classi che estendono org.apache.struts.action.ExceptionHandler ed il cui metodo execute() viene eseguito dal framework al verificarsi della corrispondente eccezione.
<global-exceptions> <exception key="label.eccezione" type="it.esempi.MiaException" handler="it.esempi.ExceptionHandler"/></global-exceptions>
Gestione delle eccezioni
it.esempi.ExceptionHandler , che estende org.apache.struts.action.ExceptionHandler, gestisce le eccezioni di tipo it.esempi.MiaException al verificarsi di una eccezione di questo tipo il framework manderà in esecuzione il metodo execute() della classe handler così dichiarata.
In questo metodo in genere è opportuno inserire del codice per effettuare il log dell'eccezione, memorizzando tutte le informazioni utili alla comprensione del problema che la ha generata, quali il messaggio associato all'eccezione, lo stack-trace etc. Il metodo restituisce in output un oggetto della classe ActionForward che consente di effettuare il forward alla risorsa desiderata
Gestione delle eccezioni
Suggerimenti pratici
preferibile dichiarare delle global exceptions almeno per quelle eccezioni comuni a tutte le Action, lasciando alla dichiarazione della singola Action solo i casi particolari di eccezioni possibili solo in quel contesto
Se non è necessaria una gestione estremamente particolareggiata è possibile dichiarare una classe handler per la java.lang.Exception che gestirà quindi in maniera centralizzata tutte le possibili eccezioni.
Gestione delle eccezioni
casi in cui non è possibile non inserire blocchi try/catch all'interno del codice. Basti pensare al caso di codice che esegue in modo programmatico una transazione su un database e che necessita di gestire le situazioni di eccezione per effettuare correttamente il commit o il rollback della transazione stessa. In tal caso lo sviluppatore è obbligato ad inserire uno o più blocchi catch al cui interno eseguire l'operazione di rollback per annullare la transazione corrente.
Validator di struts
Validazione dei dati immessi in un form HTML metodo validate() della classe org.apache.struts.action. ActionForm costituisce il punto nel quale vengono effettuati i controlli lato server sui dati immessi
Problemi:
codice di validazione è spesso duplicato
cambiamento delle regole di validazione implica una modifica ai sorgenti.
Validator di Struts
Validator è un framework che fornisce gli strumenti per effettuare in modo automatico e dichiarativo i controlli formali sui campi digitati in un form HTML.
Il Validator costituito da un insieme di classi predisposte per eseguire tutti i più comuni controlli di validazione in genere usati nelle applicazione
possibile di creare routine di validazione non fornite dal Validator
supporta sia la validazione server-side che quella client-side mediante opportune funzioni JavaScript, non fornita dal meccanismo standard degli ActionForm di Struts.
Validator di Struts
Nel file validator-rules.xml vengono dichiarate tutte le routine di validazione disponibili, i loro nomi logici e il codice JavaScript corrispondente a ciascuna routine di validazione per l'esecuzione dei controlli client-side
Nel file validation.xml si specifica come queste routine vengano applicate ai vari campi di input dei form dell'applicazione, ai quali si fa riferimento mediante i nomi dei form beans dichiarati nello struts-config.xml
step:
1. Abilitare il Validator plug-in
2. Configurare i due file XML appena citati, validator-rules.xml e validation.xml
3. Creare form bean che estendano gli ActionForm del Validator.
Validator di Struts
Il Validator viene configurato come un plug-in di Struts. Per abilitare il Validator bisogna aggiungere nello struts-config.xml le seguenti righe;<plug-in className="org.apache.struts.validator.ValidatorPlugIn"><set-property property="pathnames" value="/WEB-INF/validator-rules.xml, /WEB-INF/validation.xml"/></plug-in>
In questo modo Struts all'avvio dell'applicazione carica e inizializza il Validator; si può notare come vengano definiti i percorsi dei due file XML di configurazione del Validator.
Validator di Struts
Sono già presenti gran parte delle comuni esigenze per ciò che riguarda i controlli formali da eseguire sui campi di input di un form
<form-validation>
<global>
<validator name="required"
classname="org.apache.struts.validator.FieldChecks"
method="validateRequired"
methodParams="java.lang.Object,
org.apache.commons.validator.ValidatorAction,
org.apache.commons.validator.Field,
org.apache.struts.action.ActionErrors,
javax.servlet.http.HttpServletRequest"
msg="errors.required">
<javascript>
<
Validator di Struts
Come già accennato per utilizzare il Validator i form bean dell'applicazione non devono estendere la classe ActionForm standard di Struts ma la classe org.apache.struts.validator.ValidatorForm che fornisce l'implementazione del metodo validate(). In questo caso non è più necessario scrivere il codice di validazione perché è il Validator che lo fa per noi; non bisogna implementare neanche il reset()
public class LogonForm extends ValidatorForm {…
<form-beans><form-bean name="logonForm“ type="it.prove.LogonForm"/></form-beans>
Validator di Struts
Il nome dato al form bean nello struts-config.xml è usato nel validation.xml per far riferimento al form in questione. Il validation.xml viene usato per dichiarare i controlli che verranno effettuati sui campi di input di un form dell'applicazione
<form-validation><formset><form name="logonForm">
<field property="username“ depends="required"><arg0 key="label.username"/></field><field property="password“ depends="required"><arg0 key="label.password"/>
</field></form></formset></form-validation>
Validator di Struts
Per i messaggi di errore associati a ciascuna routine di validazione il Validator utilizza il file ApplicationResource.properties di Struts. In questo file vengono definiti i messaggi di errore associati a ciascun criterio di validazione definito nel validator-rules.xml :
errors.required={0} is requirederrors.minlength={0} cannot be less than {1} characters.
Validator di Struts
Il Validator foirnisce anche il supporto alla validazione client-side dei form dell'applicazione. Le funzioni JavaSctipt associate ai diversi criteri di validazione sono definite nel file validator-rules.xml come già visto. Per abilitare la validazione client-side è sufficiente inserire nelle pagine JSP dell'applicazione il seguente tag:
<html:javascript formName="logonForm"/>
Nel nostro caso genererà la funzione validateLogonForm() che effettuerà la validazione del form purchè la si colleghi al submit dello stesso come segue:<html:form action="logonAction" onsubmit="return validateLogonForm (this)">
Chiaramente il submit del form non avverrà se i controlli sui campi non hanno successo
Esempio di validazione
<form name="nomeForm"> <!-- definiamo il nome del Form --> <field property="nome" depends="minlength"> <arg0 key="nomeForm.nome" /> <arg1 key="${var:minlength}"
<!-- definiamo arg1 come minlenght --> name="minlength" resource="false" />
<var> <var-name>minlength</var-name><!--dichiariamo che la lunghezza minima deve essere di 5 car --> <var-value>5</var-value> </var> </field> </form>
Nel resource bundleerrors.minlength={0} non può essere meno di {1} caratteri.#{0} fa riferimento ad arg0 mentre {1} ad arg1
Regole già presenti nel validator
required: controlla se il campo non è vuoto validwhen: il campo è valido quando la condizione specificata si verifica minlength: il campo deve avere minimo un certo numero di caratteri maxlength: il campo deve avere massimo un certo numero di caratteri mask: il campo deve contenere certi tipi di caratteri byte: vede se il valore del campo è un byte short: vede se il valore del campo è uno short integer: vede se il valore del campo è un intero long: vede se il valore del campo è un long float: vede se il valore del campo è un float double: vede se il valore del campo è un double date: vede se il valore del campo è una data email: vede se il campo è un indirizzo mail url: vede se il campo è un url
Creazione di una propria regola di validazione
Creare una classe che contenga i metodi di validazione del tipopublic static boolean validateXXX (Object,org.apache.commons.validator.ValidatorAction, org.apache.commons.validator.Field, org.apache.struts.action.ActionMessages, org.apache.commons.validator.Validator, javax.servlet.http.HttpServletRequest)
Esempio di regola di validazione
public class MyValidator implements Serializable
{
public static boolean validateDistretto(Object bean, ValidatorAction va, Field field,
ActionMessages errors,Validator vl, HttpServletRequest request)
{
String value = null;
if((field.getProperty()!=null)&&(field.getProperty().length()>0))
{
value = ValidatorUtils.getValueAsString(bean, field.getProperty());
if((value.equals(""))||(value.equals("0")))
{
errors.add(field.getKey(), Resources.getActionMessage(request, va, field));
}
}
return errors.isEmpty();
}
}
Struts Tag Library
Sono
HTML (ex Form)
BEAN
LOGIC
TEMPLATE
NESTED
Struts Tag Library
Modalità di accesso alle proprietà del bean
Proprietà semplici
user.address
Proprietà annidate
user.address.city
Proprietà indicizzate
user.address[2]
Struts tag library
HTML esempi
<html:base/>crea il tag html base che punte alla colocazione della pagina assoluta che lo contiene per gestiere poi src e simili<base href=“http://localhost:8080/appl/index.jsp”>
Struts tag library
<html:form
Action :url dell’action Enctype: codifica del contenuto (multipart/form-data per upload) Focus: nome del campo con focus Method: metodo http Name: nome dell’actionForm, se non specificato si guarda il name
del tag action in struts-config Onreset, onsubmit: gestore Javascript Scope: scope dell’action form Style, styleClass, styleId:stile, classe e id HTML Target: frame target a cui inviare i dati della form Type: nome completo della classe dell’actionForm
Struts tag library
<html: messages e <html:errors
empty Evaluate the nested body content of this tag if the requested variable is either null or an empty string.
equal Evaluate the nested body content of this tag if the requested variable is equal to the specified value.
forward Forward control to the page specified by the specified ActionForward entry.
greaterEqual Evaluate the nested body content of this tag if the requested variable is greater than or equal to the specified value.
greaterThan Evaluate the nested body content of this tag if the requested variable is greater than the specified value.
iterate Repeat the nested body content of this tag over a specified collection.
lessEqual Evaluate the nested body content of this tag if the requested variable is less than or equal to the specified value.
lessThan Evaluate the nested body content of this tag if the requested variable is less than the specified value.
match Evaluate the nested body content of this tag if the specified value is an appropriate substring of the requested variable.
messagesNotPresent Generate the nested body content of this tag if the specified message is not present in this request.
messagesPresent Generate the nested body content of this tag if the specified message is present in this request.
notEmpty Evaluate the nested body content of this tag if the requested variable is neither null, nor an empty string, nor an empty java.util.Collection (tested by the .isEmpty() method on the java.util.Collection interface).
notEqual Evaluate the nested body content of this tag if the requested variable is not equal to the specified value.
notMatch Evaluate the nested body content of this tag if the specified value is not an appropriate substring of the requested variable.
notPresent Generate the nested body content of this tag if the specified value is not present in this request.
present Generate the nested body content of this tag if the specified value is present in this request.
redirect Render an HTTP Redirect
Struts Tag library
base - renders an HTML base element
button - renders a button input fiels
cancel - renders a cancel button
checkbox - renders a checkbox input field
errors - conditionnaly renders a set of accumulated error messages
file - renders a file select input field
form - defines an HTML form element
frame - renders an HTML frame element
hidden - renders a hidden field
html - renders an HTMl html element
image - renders an input tag of type "image"
img - renders an HTMl img tag
javascript - renderts JavaScript validation rules loaded by ValidationPlugin
link - renders an HTML anchoror hyperlink
messages - Conditionally displays a set of accumulated messages
multibox -renders multiple checkbox input fields
option - renders a select option
options - renders a collection of select options
options Collection - render a collection of select options
password -renders apassword input field
radio -renders a radio button input field
reset -renders a rest button input field
rewrite - renders a URI
select -renders a select element
submit -renders a submi button
text -renders an input field of type "text"
textarea -renders an textarea input field
