Newsgroup: it.comp.java
Titolo: Struts: ValidatorForm e pre-popolazione dati

Un saluto a tutti.
Sto studiando Struts e vorrei una mano per capire alcuni particolari in
merito all'utilizzo delle ValidationForm nella scrittura di
Applicazioni Web che utilizzano Struts.
Nella mia WebApp scrivo una ActionForm: posso pre-popolare il form con
i miei dati di default riscrivendo il metodo reset() e posso eseguire
la loro validazione riscrivendo il metodo Validate(). Fin qui e' tutto
chiaro.
Se decido di utilizzare il Validator Framework: la configurazione la
eseguo tramite i due files validator-rules.xml e validation.xml e non
devo piu' scrivere una ActionForm ma una ValidateForm. Anche qui nessun
problema: la validazione dei dati sara' a posto.
Ma in questo secondo caso come posso pre-popolare la mia form dato che
il metodo reset() non esiste ?
Una occhiata superficiale (lo ammetto...) al Cavaness non mi e' stata
di aiuto ed in giro e non sono riuscito a trovare "dritte" in merito.
Forse non e' possibile ?
Vi ringrazio anticipatamente.
Michele Chiarappa
mikech...@libero.it


E' un po' che non uso Struts ma ValidatorForm estende ActionForm quindi 
reset la puoi usare. 


Perchè usi reset? Tu chiami la Action che popola il bean ActionForm con i
getter e setter opportuni e con funzioni interne al bean o esterne, poi la
controller passa il tutto alla jsp con la form che a questo punto è già
popolata. Il submit della form va poi ad un'altra Action che tratta reset,
cancel e submit.

 cancel e submit.
Potresti per favore spiegarmi come e' fatta una "Action che popola il
bean ActionForm" o perlomeno rimandarmi ad un link o a della
documentazione ?
Per quanto sono riuscito a documentarmi (Cavaness compreso) ho visto
solo degli esempi di Action in cui e' ridefinito solo metodo execute().
Ma questo e' eseguito solo quando faccio il submit della form.
Grazie ancora
Michele Chiarappa
mikech...@libero.it

 ha scritto nel messaggio
news:1128440085....@z14g2000cwz.googlegroups.com...
Allora abbiamo 2 jsp: elenco.jsp e edit.jsp, poi abbiamo 1 form bean
EditForm.java e 2 action: EditAction.java e SaveAction.java.
Elenco.jsp è una lista di record letti da un db e edit.jsp è la form che
edita il singolo record.
Da elenco.jsp premo un link (<html:link
action="edit.do?numero_record=1".....>) che chiama la action EditAction (nel
config abbiamo messo edit.do uguale a EditAction).
Nel metodo execute della EditAction leggiamo il parametro "numero_record",
apriamo il db, leggiamo il record e, tramite i setter di EditForm riempiamo
la form. EditAction passa poi alla pagina jsp mappata nel config e che è
edit.jsp. Questa pagina conterrà quindi i dati del record.
La form di edit.jsp ha come action save.do mappato a SaveAction. Es.
<html:form action="save" ..>.
La SaveAction tratta i vari casi Cancel, Reset e Submit. Ad esempio se è
stato premuto Cancel fai l'istruzione:
if (isCancel(request)) ....... else (codice della parte submit).
Spero di averti aiutato. Aggiungo che, di tutti i libri su Struts, a mio
avviso il migliore è il librone rosso della Wrox sulle JSP. La guida nel
sito Apache e gli esempi forniti sono da imparare a memoria :-)

 tramite i setter di EditForm riempiamo la form.
Per fare una prova ho semplificato ancora di piu' questa situazione:
il form edit.jsp contiene solo due campi stringa "Campo1" e "Campo2"
quindi la relativa EditForm.java dovrebbe essere la seguente:
  public class EditForm extends ActionForm {
      private String campo1;
      private String campo2;
      public EditForm() {
          setCampo1("");
          setCampo2("");
      }
      public String getCampo1() {
          return campo1;
      }
      public String setCampo1(String campo) {
          this.campo1 = campo;
      }
      public String getCampo2() {
          return campo2;
      }
      public String setCampo2(String campo) {
          this.campo2 = campo;
      }
  }
La EditAction invece, mi interessa che faccia solo il
riempimento dei campi, quindi dovrebbe essere fatta cosi':
public class EditAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response) {
        EditForm editForm = ((EditForm) form;
        editForm.setCampo1("Valore Campo 1");
        editForm.setCampo2("Valore Campo 2");
        ActionForward forward = mapping.findForward("ok");
        return forward;
}
E se ho ben capito in struts-config.xml dovrei avere nella sezione
relativa al mapping qualcosa del genere:
  <action-mapping>
    <action path="AzioneEdit"
            type="Myclass.EditAction"
            name="EditForm"
            input"/edit.jsp"
    </action>
    . . .
  </action-mapping>
In queste condizioni, quando chiamo la action [AzioneEdit] il metodo
execute() della EditAction non viene eseguito mentre viene
visualizzato il form [edit.jsp].
L'unica maniera che ho trovato per farlo eseguire e' stata rimuovere
le sezioni [name] ed [input], ma in questo caso viene giustamente
segnalato un errore per il fatto che il form non e' stato dichiarato
e quindi [form] nella Action e' nullo.
Ti giuro che e' davvero frustrante questa situazione: sono ormai
due giorni che ci sto sbattendo la testa.
Spero mi possa ancora dare una mano.
Grazie
Michele Chiarappa
mikech...@libero.it


Di questa action-mapping bisogna farne 2 fatte così:
<action-mapping>
    <action path="AzioneEdit"
            type="Myclass.EditAction"
            name="EditForm"
            validate=false
    </action>
    <action path="AzioneSave"
            type="Myclass.EditAction"
            name="EditForm"
            input="/edit.jsp"
    </action>
    . . .
 </action-mapping>
dove AzioneSave salva i dati o fa qualche altra cosa. La prima dichiarazione
NON valida i dati però popola form. La seconda prende i dati della form, li
controlla e, tramite input="edit.jsp", ritorna a edit.jsp se vi sono errori.
Con questa configurazione trai il massimo vantaggio da html:errors, bean
ecc. Da notare che le 2 dichiarazioni condividono la stessa formbean.
(EditForm) proprio per permettere il meccanismo.
Edit.jsp avrà la forma:
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic"%>
<html:html>
<html:errors />
<html:form action="/AzioneSave.do">
Campo1:
 <html:text property="campo1" />
 <br>
Campo2:
 <html:text property="campo2" />
 <br>
 <html:cancel>Cancel</html:cancel>
 <html:reset>Reset</html:reset>
 <html:submit>Submit</html:submit>
</html:form>
</html:html>
La AzioneSave sarà:
public class AzioenSave extends org.apache.struts.action.Action {
    public static final String FORWARD_success= "success";
    public static final String FORWARD_failure = "failure";
    public AzioneSave() {
    }
    public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) throws Exception {
     EditForm ef = (EditForm)form;
     if (isCancelled(request)) {
      System.out.println("Richiesta cancellata");
     }
     // convalido i dati ulteriormente
    // if ok scrivo o altro e return "success"
    // else setto errors e vado a "failure"
     return mapping.findForward("success");
    }
}
Vi sono altri meccanismi, ma questo è, secondo me, il più semplice e
automatico.
Ciao

Ok, risolto !!!  :o))
Nella mia applicazione di prova avevo contemporamente due problemi:
Il primo legato alla mancata impostazione di validate a "false" nella
Action di "popolazione" del form. Questo provocava la visualizzazione
della JSP ma non l'esecuzione della Action.
Il secondo legato all'IDE che utilizzo che e' NetBeans. E' uno
strumento meraviglioso... a patto che si conoscano bene alcuni suoi
"difetti storici", uno dei quali (che ho scoperto circa un anno e mezzo
fa)  e' che talvolta non basta eseguire il "Clean and Build Main
Project" per essere sicuri che effettivamente questa funzione sia
eseguita, ma bisogna cancellare manualmente dalla directory [build] del
progetto
su cui si sta lavorando, la directory [web] (sto parlando ovviamente di
Web Applications). In questa maniera il rebuild e' sicuro ;o))
In genere mi accorgo subito di questa situazione, soprattutto quando in
fase di debug mi accorgo che certe linee di codice o della JSP non
vengono "tracciate", ma la mia cattiva conoscenza di Struts mi ha fatto
pensare piu' ad un errore concettuale che ad una magagna dell'IDE.
Ti ringrazio ancora e cordialmente ti saluto.
Michele Chiarappa
mikech...@libero.it