• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
02 Struts Actions3016
 

02 Struts Actions3016

on

  • 724 views

 

Statistics

Views

Total Views
724
Views on SlideShare
718
Embed Views
6

Actions

Likes
0
Downloads
20
Comments
0

1 Embed 6

http://www.slideshare.net 6

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    02 Struts Actions3016 02 Struts Actions3016 Presentation Transcript

    • Jakarta Struts: Processare le richieste con gli Action Objects Struts Versione 1.2 Core Servlets & JSP book: www.coreservlets.com More Servlets & JSP book: www.moreservlets.com Servlet/JSP/Struts/JSF Training: courses.coreservlets.com Traduzione a cura di JavaStaff.com
    • Agenda
      • Flusso di controllo di Struts
      • I sei passi base per l’utilizzo di Struts
        • Per implementare il flusso di controllo
      • Esempi
    • Il flusso di controllo di Struts JSP Form Determina la Action Action Sceglie la pagina JSP JSP richiesta .../SomeForm.jsp Invio form richiesta .../ blah .do invoca esegue un metodo Ritorna condizione Forward verso Ritorna risultato finale struts-config.xml
    • Il flusso di controllo di Struts
      • L’utente richiede un form
        • Per ora utilizziamo il semplice HTML per costruire la form
          • Successivamente utilizzeremo il tag Struts html:form
      • Il form è inviato ad un URL della forma blah .do.
        • Questo indirizzo è mappato ad un Action class nel file di configurazione struts-config.xml
      • Il metodo execute dell’oggetto Action viene invocato
        • Uno degli argomenti è un form bean che è automaticamente creato e le cui proprietà sono popolate automaticamente con i dati che arrivano dal form
        • L’oggetto Action dopo invoca la business logic e la data-access logic, mettendo i risultati in dei bean che vengono salvati in uno scope di request, session o application.
        • L’Action utilizza mapping.findForward per ritornare una condizione, e le condizioni sono mappate nel file struts-config.xml per effettuare il forward verso diverse pagine JSP.
      • Struts ridirige le richieste verso la pagina JSP appropriata
        • La pagina può utilizzare bean:write o l’EL di JSP 2.0 per stampare le proprietà dei bean
        • La pagina può utilizzare bean:message per stampare determinate stringhe
    • I sei passi base per utilizzare Struts
      • Modificare struts-config.xml. Si utilizza WEB-INF/struts-config.xml per:
        • Mappare gli indirizzi in entrata.do verso le classi Action
        • Mappare le condizioni di ritorno della pagine JSP
        • Dichiarare i form beans che devono essere usati.
        • Riavviate il server una volta modificato il file struts-config.xml .
      • Definire un form bean.
        • Questo bean è una classe che estende ActionForm e rappresenterà i dati inviati dall’utente. E’ automaticamente valorizzato quando la form di input viene inviata. La definizione dei bean è rinviata alla prossima lezione.
    • I sei passi base per utilizzare Struts
      • Creare i bean per il risultato.
        • Nell’architettura MVC architecture, il codice relativo alla business-logic e data-access crea i risultati e le pagine JSP li presentano. Per trasferire i risultati da un layer all’altro si utilizzano dei bean dove vengono memorizzati questi valori. Questi bean differiscono dai form bean perchè non hanno bisogno di estendere alcuna classe particolare e rappresentano l’output del processo computazionale, non l’input. I bean verranno discussi nella prossima lezione.
      • Definire una classe Action per gestire le richieste.
        • Il file struts-config.xml definisce le classi Action classes che gestiscono le richieste per differenti URL. Gli oggetti Action hanno bisogno di fare il vero lavoro: invocare la business-logic (e/o data-access-logic), salvare dei risultati in dei bean e definisce il tipo di situazione appropriata in base ai risultati (dati mancanti, errore sul database, categoria di successo 1, categoria di successo 2 etc. etc.). Il file struts-config.xml dopo decide quale pagina JSP deve essere applicata a questa situazione.
    • I sei passi base per utilizzare Struts
      • Creare il form che invoca blah .do.
        • Creare un form di input la cui ACTION corrisponde ad uno degli indirizzi contenuti nel file struts-config.xml.
        • In una lezione successiva si parlerà dei vantaggi dell’utilizzo del tag html:form di Struts per costruire i form di input.
      • Display dei risultati nelle JSP.
        • Visto che Struts è costruito sul pattern MVC, queste pagine JSP dovrebbero evitare elementi di scripting ove possibile. Si può usare il tag bean:write, ma anche l’EL di JSP 2.0 è alternativa possibile.
        • Nella maggior parte dei casi, le pagine JSP hanno senso solo quando la richiesta è inviata attraverso una Action.
        • Se le pagine JSP hanno senso indipendentemente dalla Action, allora queste pagine dovrebbero essere poste in una sottodirectory della Web application e le entry di forward entries nel file struts-config.xml dovrebbero riportare <forward ... redirect=&quot;true&quot;/>.
    • Esempio 1: Mapping di un risultato
      • URL
        • http://hostname/StrutsActions/register1.do
      • Action Class
        • RegisterAction1
          • RegisterAction1 estende Action ed è presente nel package di com.javastaff.strutsaction.
          • Il metodo execute di RegisterAction1 ritorna sempre &quot;success&quot;
      • Pagina dei risultati
        • /WEB-INF/results/confirm.jsp
          • L’URL mostrato sarà sempre register1.do
    • Passo 1A (Modificare struts-config.xml)
      • Mappare gli indirizzi in arrivo .do con delle classi Action
        • In questo caso abbiamo deciso che la classe RegisterAction1 deve gestire le richieste per l’indirizzo register1.do. Per assolvere a questo compito, dobbiamo aggiungere una entry action al tag action-mappings, dove la action deve avere i seguenti attributi.
          • path : il path relativo che deve essere mappato sulla Action, tranne l’estensione .do. Così il path=&quot;/register1&quot; si riferisce all’URL http://hostname/webAppName/register1.do.
          • type : il nome completo della classe Action che deve essere invocato per gestire la richiesta.
      • <action-mappings>
      • <!-- .do implied automatically -->
      • <action path=&quot;/register1&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction1&quot;>
      • ...
      • </action>
      • </action-mappings>
    • Passo 1B (Modificare struts-config.xml)
      • Mappare le condizioni di ritorno con delle pagine JSP
        • In questo caso utilizziamo l’elemento forward per dire che la pagina confirm.jsp viene applicata quando il metodo execute di RegisterAction1 ritorna &quot;success&quot;, come segue :
        • <forward name=&quot;success&quot; path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
        • Nota: se lo stesso forward è utilizzato da azioni multiple, è possibile inserirlo in una sezione global-forwards section (prima di action-mappings) invece che metterlo dentro la action.
        • <global-forwards>
        • <forward name=&quot;success&quot; path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
        • </global-forwards>
    • Passo 1 (Modificare struts-config.xml) – Il file struts-config.xml finale
      • <?xml version=&quot;1.0&quot; encoding=&quot;ISO-8859-1&quot; ?>
      • <!DOCTYPE struts-config PUBLIC ... >
      • <struts-config>
      • <action-mappings>
      • <action path=&quot;/register1&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction1&quot;>
      • <forward name=&quot;success&quot;
      • path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </action>
      • </action-mappings>
      • </struts-config>
    • Passo 2 e 3
      • Definire un form bean.
        • I bean sono rimandati alla prossima lezione, quindi questo step è omesso per il momento.
      • Creare dei result bean.
        • I bean sono rimandati alla prossima lezione, quindi questo step è omesso per il momento.
    • Passo 4 (Definire una classe Action per gestire le richieste)
      • Le sottoclassi Action dovrebbero… essere in un package .
        • In questo caso abbiamo package com.javastaff.strutsaction;
          • Questo significa che il file class dovrebbe andare in web_app /WEB-INF/classes/com/javastaff/strutsaction.
      • Le sottoclassi Action dovrebbero… aggiungere gli import specifici per Struts o qualsiasi altro importo necessario .
        • In questo caso abbiamo
        • import javax.servlet.http.HttpServletRequest;
        • import javax.servlet.http.HttpServletResponse;
        • import org.apache.struts.action.Action;
        • import org.apache.struts.action.ActionForm;
        • import org.apache.struts.action.ActionMapping;
        • import org.apache.struts.action.ActionForward;
    • Passo 4 (Definire una classe Action per gestire le richieste)
      • Le sottoclassi Action dovrebbero ... estendere Action
      • Le sottoclassi Action dovrebbero ... effettuare l’override del metodo execute
        • In questo caso abbiamo
      • public class RegisterAction1 extends Action {
      • public ActionForward
      • execute (ActionMapping mapping,
      • ActionForm form,
      • HttpServletRequest request,
      • HttpServletResponse response)
      • throws Exception {
      • ...
      • }
      • }
    • Passo 4 (Definire una classe Action per gestire le richieste)
      • Le sottoclassi Action dovrebbero... Ritornate mapping.findForward .
        • Il metodo execute dovrebbe avere uno o più valori di ritorno.
        • Questi valori corrisponderanno a specifiche pagine JSP definite nelle entry forward del file struts-config.xml. In questo caso ritorniamo semplicemente &quot;success&quot; in ogni situazione.
      • public ActionForward
      • execute(ActionMapping mapping,
      • ActionForm form,
      • HttpServletRequest request,
      • HttpServletResponse response)
      • throws Exception {
      • return(mapping.findForward(&quot;success&quot;));
      • }
    • Passo 4 (Definire una classe Action per gestire le richieste) – Codice finale
      • package com.javastaff.strutsaction;
      • import javax.servlet.http.HttpServletRequest;
      • import javax.servlet.http.HttpServletResponse;
      • import org.apache.struts.action.Action;
      • import org.apache.struts.action.ActionForm;
      • import org.apache.struts.action.ActionMapping;
      • import org.apache.struts.action.ActionForward;
      • public class RegisterAction1 extends Action {
      • public ActionForward execute(ActionMapping mapping, ActionForm form,
      • HttpServletRequest request, HttpServletResponse response)
      • throws Exception {
      • return mapping.findForward(&quot;success&quot;);
      • }
      • }
    • Passo 5 (Creare il form che richiama register1 .do)
      • Abbiamo bisogno di un form HTML che richiama http://hostname/struts-actions/register1.do.
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>New Account Registration</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>New Account Registration</H1>
      • <FORM ACTION=&quot;register1.do&quot; METHOD=&quot;POST&quot;>
      • Email address: <INPUT TYPE=&quot;TEXT&quot; NAME=&quot;email&quot;><BR>
      • Password: <INPUT TYPE=&quot;PASSWORD&quot; NAME=&quot;password&quot;><BR>
      • <INPUT TYPE=&quot;SUBMIT&quot; VALUE=&quot;Sign Me Up!&quot;>
      • </FORM>
      • </CENTER>
      • </BODY></HTML>
    • Passo 6 (Display dei risultati nella JSP)
      • In generale, a questo punto possono esserci diverse pagine
        • Ogni pagina può corrispondere ai diversi valori che vengono ritornati dal metodo execute della Action invocata.
      • Nel file struts-config.xml, ogni pagina JSP è dichiarata in una entry forward con la relativa action.
        • In questo semplice caso l’unico valore di ritorno è &quot;success&quot;, così /WEB-INF/results/confirm.jsp è usata in tutti i casi.
      • Questa pagina JSP mostrerà un semplice messaggio (come potete vedere nella prossima slide)
    • Passo 6 (Display dei risultati nella JSP) – Codice finale
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>Success</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>You have registered successfully.</H1>
      • Congratulations
      • </CENTER>
      • </BODY></HTML>
    • Esempio 1: Risultati
      • Il form HTML viene invocato con l’URL http://localhost/StrutsAction/form.html
    • Esempio 1: Risultati
      • Questo form viene riempito ed in seguito inviato
        • L’ ACTION del form è register1.do
      • Questo indirizzo è mappato nel file di configurazione struts-config.xml
        • E’ associato alla classe RegisterAction1, della quale viene invocato il metodo execute.
      • Questo metodo ritorna mapping.findForward
        • Con il valore &quot;success“, definito staticamente
      • Questo valore è mappato in struts-config.xml
        • Gestisce il forward verso /WEB-INF/results/confirm.jsp,
          • Che è il risultato finale mostrato all’utente.
          • Tuttavia visto che la pagina è invocata con RequestDispatcher.forward, e non response.sendRedirect, l’URL mostrato all’utente è register1.do, non confirm.jsp.
    • Esempio 1: Risultati
    • Esempio 2: Mapping multipli per il risultato
      • URL
        • http://hostname/StrutsAction/register2.do
      • Action Class
        • RegisterAction2.
          • Il metodo execute di RegisterAction2 ritorna &quot;success&quot;, &quot;bad-address&quot;, o &quot;bad-password&quot;
      • Pagine dei risultati
        • /WEB-INF/results/confirm.jsp,
        • /WEB-INF/results/bad-address.jsp, e
        • /WEB-INF/results/bad-password.jsp
      • Nuova feature di questo esempio
        • L’uso di forward multipli in un elemento action.
    • Passo 1 (Modificare struts-config.xml)
      • Mappare gli indirizzi .do con le classi Action
        • In questo caso utilizziamo RegisterAction2 per gestire le richieste relative a register2.do (come prima, notare che il .do è implicito).
      • Mappare le condizioni ritornate con delle pagine JSP
        • In questo caso utilizziamo degli elementi forward multipli, uno per ogni possibile valore di ritorno del metodo execute di RegisterAction2.
      • Dichiarare tutti i form bean che devono essere usati.
        • I Bean sono rimandati alla prossima lezione quindi per il momento sono omessi.
    • Passo 1 (Modificare struts-config.xml) – Codice finale
      • <?xml version=&quot;1.0&quot; encoding=&quot;ISO-8859-1&quot; ?>
      • <!DOCTYPE struts-config PUBLIC ... >
      • <struts-config>
      • <action-mappings>
      • ...
      • <action path=&quot;/register2&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction2&quot;>
      • <forward name=&quot;bad-address&quot;
      • path=&quot;/WEB-INF/results/errorEmail.jsp&quot;/>
      • <forward name=&quot;bad-password&quot;
      • path=&quot;/WEB-INF/results/errorPassword.jsp&quot;/>
      • <forward name=&quot;success&quot;
      • path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </action>
      • </action-mappings>
      • </struts-config>
    • Passi 2 e 3
      • Definire un form bean.
        • I Bean sono rimandati alla prossima lezione quindi per il momento sono omessi.
      • Creare i bean dei risultati.
        • I Bean sono rimandati alla prossima lezione quindi per il momento sono omessi.
    • Passo 4 (Definire una classe Action per gestire le richieste)
      • Simile al precedente esempio tranne per il fatto che ora inseriamo diverse entry nel mapping.findForward
        • Ritorniamo un &quot;bad-address&quot; se l’email non è presente nel form, se è più piccola di 3 caratteri o se manca il carattere &quot;@&quot;.
        • Ritorniamo &quot;bad-password&quot; se la password è mancante o se è più piccola di 6 caratteri.
        • Altrimenti ritorniamo &quot;success&quot;.
      • In questo semplice esempio utilizziamo esplicitamente request.getParameter.
        • Nelle lezioni successive vedremo come Struts popola automaticamente un bean a partire dai dati della request HTTP.
    • Passo 4 (Definire una classe Action per gestire le richieste) – Codice finale
      • public class RegisterAction2 extends Action {
      • public ActionForward
      • execute(ActionMapping mapping,
      • ActionForm form,
      • HttpServletRequest request,
      • HttpServletResponse response)
      • throws Exception {
      • String email = request.getParameter(&quot;email&quot;);
      • String password = request.getParameter(&quot;password&quot;);
      • if ((email == null) ||
      • (email.trim().length() < 3) ||
      • (email.indexOf(&quot;@&quot;) == -1)) {
      • return(mapping.findForward(&quot;bad-address&quot;));
      • } else if ((password == null) ||
      • (password.trim().length() < 6)) {
      • return(mapping.findForward(&quot;bad-password&quot;));
      • } else {
      • return(mapping.findForward(&quot;success&quot;));
      • }}}
    • Passo 5 (Creare il form che invoca blah .do)
      • Abbiamo bisogno di un form che invoca http://hostname/StrutsAction/register2.do.
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>New Account Registration</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>New Account Registration</H1>
      • <FORM ACTION=&quot;register2.do&quot; METHOD=&quot;POST&quot;>
      • Email address: <INPUT TYPE=&quot;TEXT&quot; NAME=&quot;email&quot;><BR>
      • Password: <INPUT TYPE=&quot;PASSWORD&quot; NAME=&quot;password&quot;><BR>
      • <INPUT TYPE=&quot;SUBMIT&quot; VALUE=&quot;Sign Me Up!&quot;>
      • </FORM>
      • </CENTER>
      • </BODY></HTML>
    • Passo 6 (Visualizzare i risultati in una JSP) Prima possibile pagina
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>Illegal Email Address</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>Illegal Email Address</H1>
      • Address must be of the form username@host.
      • Please <A HREF=“form2.html&quot;>
      • try again</A>.
      • </CENTER>
      • </BODY></HTML>
    • Passo 6 (Visualizzare i risultati in una JSP) Seconda possibile pagina
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>Illegal Password</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>Illegal Password</H1>
      • Password must contain at least six characters.
      • Please <A HREF=“form2.html&quot;>
      • try again</A>.
      • </CENTER>
      • </BODY></HTML>
    • Passo 6 (Visualizzare i risultati in una JSP) confirm.jsp già utilizzata
      • <!DOCTYPE ...>
      • <HTML>
      • <HEAD><TITLE>Success</TITLE></HEAD>
      • <BODY BGCOLOR=&quot;#FDF5E6&quot;>
      • <CENTER>
      • <H1>You have registered successfully.</H1>
      • Congratulations
      • </CENTER>
      • </BODY></HTML>
    • Esempio 2: Risultati (Form iniziale)
    • Esempio 2: Risultati (Indirizzo sbagliato)
    • Esempio 2: Risultati (Password sbagliata)
    • Esempio 2: Risultati (Successo)
    • Combinare condizioni condivise per i vari mapping
      • Idea
        • Se la stessa condizione è mappata sulla stessa pagina JSP in diverse azioni, è possibile muovere questo forward in una sezione global-forwards per evitare inutili ripetizioni
      • Sintassi
        • La sezione global-forwards precede action-mappings
        • Le entry di forward in global-forwards hanno la stessa sintassi e lo stesso comportamento delle entry di forward nelle action
      • Esempio
      • <global-forwards>
      • <forward name=&quot;success&quot; path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </global-forwards>
    • Combinare condizioni condivise per i vari mapping: vecchia configurazione
      • <action-mappings>
      • <action path=&quot;/register1&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction1&quot;>
      • <forward name=&quot;success&quot;
      • path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </action>
      • <action path=&quot;/register2&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction2&quot;>
      • <forward name=&quot;bad-address&quot;
      • path=&quot;/WEB-INF/results/errorEmail.jsp&quot;/>
      • <forward name=&quot;bad-password&quot;
      • path=&quot;/WEB-INF/results/errorPassword.jsp&quot;/>
      • <forward name=&quot;success&quot;
      • path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </action>
      • ...
      • </action-mappings>
    • Combinare condizioni condivise per i vari mapping: nuova configurazione
      • <global-forwards>
      • <forward name=&quot;success&quot;
      • path=&quot;/WEB-INF/results/confirm.jsp&quot;/>
      • </global-forwards>
      • <action-mappings>
      • <action path=&quot;/register1&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction1&quot;>
      • </action>
      • <action path=&quot;/register2&quot;
      • type=&quot;com.javastaff.strutsaction.RegisterAction2&quot;>
      • <forward name=&quot;bad-address&quot;
      • path=&quot;/WEB-INF/results/errorEmail.jsp&quot;/>
      • <forward name=&quot;bad-password&quot;
      • path=&quot;/WEB-INF/results/errorPassword.jsp&quot;/>
      • </action>
      • ...
      • </action-mappings>
    • Sommario
      • Modificare struts-config.xml
        • Mappare indirizzi blah .do su delle classi che estendono Action
        • Mappare le condizioni di return su delle pagine JSP
        • Dichiarare tutti i form bean che devono essere utilizzati.
      • Definire un form bean
      • Creare un bean dei risultati
      • Definire una classe Action che gestisce le richieste
        • Estendere Action
        • Effettuare l’override di execute()
        • Ritornare mapping.findForward
      • Creare un form che invoca blah .do
      • Mostrare i risultati in una JSP