3. Processamento do formulário pelo controlador
Vamos agora concentrar-nos na forma como o controlador processa os valores do formulário quando o utilizador clica no botão [Submit] no formulário.
3.1. O ficheiro struts-config.xml
O novo ficheiro de configuração struts-config.xml para o controlador Struts tem o seguinte aspeto:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<form-beans>
<form-bean
name="frmPersonne"
type="istia.st.struts.personne.FormulaireBean"
/>
</form-beans>
<action-mappings>
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/reponse"
parameter="/vues/reponse.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
</action-mappings>
<message-resources parameter="ressources.personneressources"/>
</struts-config>
Destacámos as alterações:
- aparece uma secção <form-beans>. É utilizada para definir as classes associadas a cada um dos formulários da aplicação. Deve haver tantas tags <form-bean> quantos forem os diferentes formulários na aplicação. Aqui, temos apenas um formulário, pelo que existe apenas uma secção <form-bean>. Para cada formulário, devemos definir:
- o seu nome (atributo name)
- o nome da classe derivada de ActionForm responsável por armazenar os valores do formulário (atributo type)
Estes dois atributos não podem ser arbitrários. Devem corresponder aos utilizados na tag <html:form> no código HTML do formulário. Recorde o código do formulário (nome, idade):
O formulário deve ser declarado da mesma forma no ficheiro struts-config.html. É isso que se faz aqui:
- A configuração da ação /main foi alterada. Esta ação é responsável pelo processamento dos valores do formulário. Por conseguinte, temos de fornecer as informações de que necessita sobre o formulário:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
O servlet /main irá processar um formulário, ao qual deve ser atribuído um nome. O atributo name trata disso. Este nome deve referir-se ao atributo name de uma das secções <form-bean>, neste caso frmPersonne.
O atributo scope="session" indica que os valores do formulário devem ser armazenados na sessão. Isto nem sempre é necessário. Aqui, é. De facto, nas vistas /reponse.do e /erreurs.do, encontramos links que remetem para o formulário. Em ambos os casos, queremos apresentar o formulário com os valores introduzidos pelo utilizador durante uma troca anterior entre o cliente e o servidor. Daí a necessidade de armazenar o formulário na sessão.
O atributo validate indica se o método validate do objeto frmPersonne deve ou não ser chamado. Este método é utilizado para verificar a validade dos dados do formulário. Aqui, especificamos que os dados devem ser verificados, o que significa que teremos de escrever um método validate na classe FormulaireBean. O método validate do formulário é chamado pelo controlador Struts antes de o servlet /main ser invocado. Ele retorna um objeto ActionErrors, que é análogo a uma lista de erros. Se esta lista existir e não estiver vazia, o controlador Struts irá parar aí e enviar a vista especificada pelo atributo input como resposta. A vista receberá a lista ActionErrors na solicitação, que pode ser exibida usando a tag <html:errors>. Acima, especificamos que, em caso de erros, o servlet /main deve enviar a vista /errors.do. Lembre-se de que esta vista está associada à seguinte URL: /views/errors.response.jsp:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html>
<head>
<title>Personne</title>
</head>
<body>
<h2>Les erreurs suivantes se sont produites</h2>
<html:errors/>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
A vista utiliza corretamente a tag <html:errors>, que irá apresentar a lista de erros. Nesta lista de erros, não encontrará mensagens de erro, mas sim identificadores de mensagens presentes no ficheiro referenciado pela tag <message-resources> (nota: recursos com um único «s»):
A tag abaixo indica que o ficheiro que contém as mensagens utilizadas pela aplicação está localizado no ficheiro WEB-INF/classes/ressources/personneressources.properties:
O que contém este ficheiro? Trata-se de um ficheiro de propriedades correspondente à classe Java Properties, ou seja, um conjunto de linhas do tipo chave=valor:
errors.header=<ul>
errors.footer=</ul>
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
Este ficheiro de mensagens tem, pelo menos, duas funções:
- permite alterar as mensagens da aplicação sem ter de a recompilar
- permite a internacionalização das aplicações Struts. Pode criar vários ficheiros de recursos, um por idioma. O Struts utilizará automaticamente o ficheiro de mensagens correto, desde que sejam seguidas determinadas convenções de nomenclatura.
- Se o método validate do formulário devolver uma lista de erros vazia, o controlador Struts chama o método execute do servlet ForwardAction. É importante compreender aqui que, quando o método execute do servlet é executado, isso significa que os dados do formulário foram considerados válidos (desde que, claro, tenham sido validados através de validate="true"). É dentro do método execute do servlet associado à ação que o programador processa efetivamente o formulário. É aqui que ocorre o núcleo do processamento (lógica da aplicação, utilização de classes de negócio e classes de acesso a dados). Por fim, o método devolve um objeto ActionForward que indica ao renderizador qual a vista a enviar de volta ao cliente. Aqui utilizámos a ação ForwardAction predefinida do Struts. O seu método execute devolve simplesmente um ActionForward que aponta para o URL especificado pelo atributo parameter:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Assim, se os dados do formulário forem válidos, a ação /main irá devolver a vista /vues/main.html que já utilizámos.
3.2. A nova classe FormBean
Já criámos uma versão inicial da classe FormBean responsável por armazenar os dados (nome, idade) do formulário formulaire.personne.jsp. Esta versão não validava os dados. Agora, temos de o fazer, uma vez que especificámos no ficheiro struts-config.xml que os dados do formulário devem ser validados (validate="true") antes de serem passados para o servlet ForwardAction. O código da classe fica assim:
package istia.st.struts.personne;
import javax.servlet.http.*;
import org.apache.struts.action.*;
public class FormulaireBean
extends ActionForm {
// name
private String nom = null;
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
// age
private String age = null;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
// validation
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// error management
ActionErrors erreurs = new ActionErrors();
// name must be non-empty
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// age must be a positive integer
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// age must be a positive integer
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// return the list of errors
}
} //if
// return the error list
return erreurs;
}
}
A nova funcionalidade reside na implementação do método validate. Este método é chamado pelo controlador Struts depois de ter preenchido os atributos name e age da classe com os valores dos campos do formulário com os mesmos nomes. Deve verificar a validade dos atributos name e age. O código acima é bastante simples:
- é criada uma lista de erros vazia (ActionErrors errors)
- o campo name é verificado. Se estiver vazio, é adicionado um erro à lista de erros utilizando o método ActionErrors.add("key", ActionError).
- O mesmo é feito se o campo age não for um inteiro.
- o método validate devolve a lista de erros (ActionErrors errors) ao controlador Struts. Se errors for nulo ou se errors.size() for 0, o controlador considera que não houve erros. Em seguida, executará o método execute da classe Action associada à ação (type="org.apache.struts.actions.ForwardAction"). Caso contrário, irá devolver a vista associada aos erros do formulário (input="/errors.do").
Um erro é adicionado à lista ActionErrors utilizando ActionErrors.add("errorKey", new ActionError("messageKey"[,param0, param1, param2, param3])). O primeiro parâmetro, "errorKey", é utilizado para identificar de forma única um elemento ActionError na lista ActionErrors, tal como num dicionário. Pode ser qualquer cadeia de caracteres. ActionError é um objeto associado a uma mensagem de erro utilizando o seu construtor ActionError(String errorKey[,String param0, String param1, String param2, String param3]), onde errorKey é o identificador da mensagem associada ao erro e até 4 parâmetros opcionais. O identificador keyMessage não é arbitrário. É um dos identificadores encontrados no ficheiro especificado pela tag <message-resources> no ficheiro struts-config.xml:
Note que este ficheiro (na verdade, WEB-INF/classes/resources/personneressources.properties) contém as seguintes chaves:
errors.header=<ul>
errors.footer=</ul>
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
Podemos verificar que as chaves de mensagem utilizadas pelo método validate da classe FormBean existem efetivamente no ficheiro acima. Utilizámos a tag HTML <li> para cada mensagem de erro, para que a tag <html:errors> as apresente como uma lista HTML. Vimos que o objeto ActionError pode ser construído não só com uma chave de mensagem, mas também com parâmetros adicionais:
Se um ActionError tiver sido construído com parâmetros adicionais (até um máximo de quatro), estes ficam acessíveis no texto da mensagem através da notação {0} a {3}. Assim, o método validate da FormulaireBean constrói um ActionError com a chave personne.formulaire.age.incorrect e o parâmetro adicional param0 age:
A mensagem associada à chave **person.form.age.incorrect** no ficheiro .properties é
O {0} será substituído pelo valor da idade. Por fim, as mensagens com as chaves errors.header e errors.footer serão escritas antes e depois da lista de erros, respetivamente. Aqui, estas duas chaves serão utilizadas para incluir as tags HTML <ul> e </ul>, que devem envolver as tags <li>.
3.3. Testes de validação do formulário
Estamos prontos para testar a validade do formulário. Segue-se um lembrete de onde os vários componentes da aplicação devem ser colocados:
 | |
 | |
 | |
 |
3.3.1. Teste 1
Reinicie o Tomcat para que ele leia os novos ficheiros de configuração e, em seguida, aceda ao URL http://localhost:8080/strutspersonne/formulaire.do:
Explicações:
- No ficheiro struts-config.html, foi utilizada a seguinte secção:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Se visualizarmos o código HTML da página recebida, vemos que a tag <form> na página é a seguinte:
O botão [Submit], que é do tipo submit, enviará, portanto, os dados do formulário para o URL /strutspersonne/main.do.
3.3.2. Teste 2
Vamos utilizar o botão [Submit] deixando os campos de entrada em branco. Obtemos a seguinte resposta:
Explicações:
- Conforme indicado acima, os dados do formulário foram enviados para o URL /strutspersonne/main.do. Foram então utilizadas as seguintes secções do ficheiro struts-config.xml:
<form-bean
name="frmPersonne"
type="istia.st.struts.personne.FormulaireBean"
scope="session"
/>
....
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
A ação /main foi acionada. Esta utiliza o formulário frmPersonne (name="frmPersonne"). O controlador Struts instanciou, portanto, se necessário, um objeto da classe FormulaireBean (type="istia.st.struts.personne.FormulaireBean" na tag form-bean). Preencheu os atributos name e age deste objeto com os campos de mesmo nome no formulário HTML:
<table>
<tr>
<td>Nom</td>
<td><html:text property="nom" size="20"/></td>
</tr>
<tr>
<td>Age</td>
<td><html:text property="age" size="3"/></td>
</tr>
<tr>
</table>
Depois de feito isto, o controlador Struts chama o método validate do objeto FormBean, porque o atributo validate da ação /main está definido como true no ficheiro de configuração:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
O método validate da classe FormBean é o seguinte:
// validation
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// error management
ActionErrors erreurs = new ActionErrors();
// name must be non-empty
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// age must be a positive integer
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// age must be a positive integer
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// return the list of errors
}
} //if
// return the error list
return erreurs;
}
Como os campos [name] e [age] estavam vazios, o método validate acima gerou uma lista de dois erros, que devolveu ao controlador Struts. Como havia erros, o controlador devolveu então a vista associada ao atributo de entrada ao cliente. Para determinar qual era essa vista, utilizou a seguinte secção do seu ficheiro de configuração:
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Por conseguinte, acabou por enviar a vista /views/errors.person.jsp. Esta vista contém o seguinte código:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html>
<head>
<title>Personne</title>
</head>
<body>
<h2>Les erreurs suivantes se sont produites</h2>
<html:errors/>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
A tag <html:errors> simplesmente exibe a lista de mensagens que lhe são enviadas pelo controlador Struts. Ela utiliza o ficheiro de mensagens especificado pela tag <message-resources>:
Este contém as seguintes chaves e mensagens:
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.vide=<li>Vous devez indiquer un age</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
errors.header=<ul>
errors.footer=</ul>
- A mensagem associada à chave errors.header é gravada
- as mensagens associadas às várias chaves na lista ActionErrors recebida são gravadas
- a mensagem associada à chave errors.footer é gravada
3.3.3. Teste 3
Vamos utilizar o link [Voltar ao formulário] na página de erro. Obtemos a seguinte página:
Explicações:
- O link [Voltar ao formulário] tem o seguinte código HTML:
O controlador Struts utilizou a seguinte secção do seu ficheiro de configuração:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Por conseguinte, devolveu a vista /views/form.person.jsp.
3.3.4. Teste 4
Preenchemos o seguinte formulário e, em seguida, clicamos no botão [Submit]:
Recebemos a seguinte resposta:
Explicações: São as mesmas do Teste 2.
3.3.5. Teste 5
Clicamos na ligação [Voltar ao formulário] acima. Vemos a seguinte página:
Vemos que o formulário está no mesmo estado em que estava quando o enviámos.
Explicações: Estas são as mesmas do Teste n.º 3, com informações adicionais:
- O formulário HTML apresentado tem as seguintes tags:
<table>
<tr>
<td>Nom</td>
<td><html:text property="nom" size="20"/></td>
</tr>
<tr>
<td>Age</td>
<td><html:text property="age" size="3"/></td>
</tr>
<tr>
</table>
As tags <html:text> têm duas funções:
- Ao enviar valores do formulário do cliente para o servidor, os valores dos campos de entrada do formulário são atribuídos aos campos com o mesmo nome no objeto FormBean
- quando o servidor envia o código HTML do formulário a ser apresentado de volta ao cliente, os atributos de valor dos campos de entrada associados às tags <html:text> são inicializados com os valores dos campos com o mesmo nome no objeto FormBean.
Aqui temos duas interações cliente-servidor diferentes:
- Na primeira, o utilizador preencheu o formulário e enviou-o para o servidor
- Na segunda, o utilizador clicou na ligação [Voltar ao formulário] para regressar ao formulário.
A única forma de o formulário ser exibido novamente com os seus valores originais na segunda interação é esses valores serem armazenados na sessão do cliente. Foi isso que foi especificado na secção de configuração da ação /main:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Se tivéssemos definido scope="request", os dados do formulário não teriam sido armazenados na sessão e não teríamos conseguido recuperar os seus valores na segunda troca.
3.3.6. Teste 6
Vamos voltar ao formulário e, desta vez, introduzir dados válidos:
Envie o formulário. Obtemos o seguinte resultado:
Explicações:
- Uma vez que o botão [Submit] envia os valores do formulário para o URL /strutspersonne/main.do, aplicam-se as mesmas explicações do Teste 2 até que o controlador Struts receba o resultado ActionErrors do método validate do FormBean. Mas, neste caso, esta lista está vazia. O controlador utiliza então uma nova parte da configuração da ação /main:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
O controlador Struts cria, se necessário, um objeto do tipo especificado pelo atributo type. O método execute desta classe é executado e deve retornar um objeto ActionForward indicando a vista que o controlador deve enviar como resposta ao cliente. Aqui, o atributo type refere-se à classe ForwardAction predefinida. O método execute desta classe não faz nada e simplesmente devolve um objeto ActionForward que aponta para a vista definida pelo atributo parameter, neste caso a vista /vues/main.html. Esta é, de facto, a vista que o controlador devolveu.
3.3.7. Teste 7
Solicitamos novamente a vista /form.do:
Vemos o formulário exatamente como o enviámos. A explicação já foi dada. Através da configuração (scope="session"), especificámos que o formulário deve permanecer na sessão. Os seus valores são, portanto, preservados ao longo das trocas cliente-servidor.
Estamos quase a terminar. Ainda precisamos de criar uma ação adequada para quando os dados do formulário forem válidos. Por enquanto, utilizámos a ForwardAction predefinida para simplificar a nossa demonstração.
3.4. Nova configuração para a ação /main
Não estamos a alterar o ficheiro de configuração struts-config.xml atual, exceto para modificar a sua secção /main da seguinte forma:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
O atributo type refere-se agora a outra classe chamada FormAction, que teremos de implementar. É o método execute desta classe que será chamado se os dados no formulário frmPersonne forem válidos. Especificámos que o método execute executa a sua tarefa e devolve um objeto ActionForward indicando a vista que o controlador deve enviar de volta ao cliente. Muitas vezes, existem várias vistas possíveis, dependendo do resultado do processamento do formulário. A lista de vistas possíveis é especificada dentro das tags <forward> incluídas na tag <action>. A sintaxe para tal tag é a seguinte:
qualquer nome que identifique de forma única uma vista | |
URL da vista associada à chave |
3.5. A classe FormAction
Escrever a classe FormAction consiste essencialmente em escrever o seu método execute:
package istia.st.struts.personne;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import javax.servlet.ServletException;
public class FormulaireAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException,ServletException {
// we have a valid form, otherwise we wouldn't have got here
FormulaireBean formulaire=(FormulaireBean)form;
request.setAttribute("nom",formulaire.getNom());
request.setAttribute("age",formulaire.getAge());
return mapping.findForward("reponse");
}//execute
}
O método execute aceita quatro parâmetros:
- ActionMapping mapping: um objeto «image» que representa a configuração da ação atualmente em execução; neste caso, uma imagem com a seguinte configuração:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
Assim, a ação tem acesso às chaves associadas às vistas que podem ser devolvidas ao cliente no final da ação. O método execute deve devolver uma dessas chaves.
- ActionForm form: o objeto bean que contém os valores do formulário utilizados pela ação atual. Aqui, trata-se do objeto frmPersonne do tipo FormBean. Assim, a ação tem acesso aos valores do formulário.
- HttpServletRequest request: o pedido do cliente, que pode ter sido enriquecido por vários servlets. A ação tem, assim, acesso a todos os parâmetros do pedido inicial (request.getParameter), bem como a todos os atributos adicionados a esse pedido inicial (request.getAttribute). No nosso exemplo, o método execute enriquece a solicitação adicionando o nome e a idade. Isso é completamente desnecessário aqui, uma vez que esses dois valores já estão presentes, mas como parâmetros em vez de atributos. O código é incluído aqui para fins ilustrativos.
- HttpServletResponse response: a resposta que será enviada ao cliente. A ação poderia enriquecer esta resposta. Aqui, não o faz.
Aqui, estamos a lidar com um caso especial. O método execute quase não tem nada para fazer. Precisa simplesmente de indicar que a próxima vista é /reponse.do e especificar na solicitação que esta vista receberá as informações de nome e idade necessárias para a sua exibição. Faz isso utilizando o método findForward da classe ActionMapping, que recebe como parâmetro uma das chaves encontradas nas tags forward da configuração da ação. Aqui, existe apenas uma tag desse tipo:
O nosso método, portanto, retorna um ActionForward com "response" como chave para indicar que a vista /response.do deve ser enviada.
3.6. Testes FormAction
Compilamos a classe anterior com o JBuilder e colocamos o ficheiro .class gerado em WEB-INF/classes:
Modificamos a vista /vues/reponse.personne.jsp:
<%
// on récupère les données nom, age
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
<html>
<head>
<title>Personne</title>
</head>
<body>
<h2>Personne - réponse</h2>
<hr>
<table>
<tr>
<td>Nom</td>
<td><%= nom %>
</tr>
<tr>
<td>Age</td>
<td><%= age %>
</tr>
</table>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
A vista recupera as informações de nome e idade a partir dos atributos da solicitação que recebe. Solicitamos o formulário na URL http://localhost:8080/strutspersonne/formulaire.do e, em seguida, preenchemo-lo:
Clicamos no botão [Submit] e recebemos a seguinte resposta:
Explicações:
- Vamos consultar a explicação fornecida para o Teste n.º 2 relativamente ao início do processo. Vamos rever a configuração da ação /main:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
- Após o formulário ter sido enviado para o controlador na URL /main.do, o controlador criou ou reutilizou um objeto frmPersonne do tipo FormBean e preencheu-o com os valores do formulário
- O método validate do objeto frmPersonne foi chamado. Como os dados eram válidos, o método validate devolveu uma lista ActionErrors vazia.
- Foi criado ou reciclado um objeto FormAction, e o seu método execute foi chamado. Este método devolveu um objeto ActionForward com a chave "reponse".
- O controlador enviou então a vista associada à chave "reponse", ou seja, /reponse.do, e, portanto, /vues/reponse.personne.jsp.
- A vista reponse.personne.jsp foi apresentada com os valores definidos na solicitação pelo método execute do objeto FormAction.
3.7. Conclusão
Criámos uma aplicação abrangente, mas simples. Ao implementá-la efetivamente com o Struts, o Tomcat e o JBuilder, há muitas oportunidades para cometer erros, especialmente nos ficheiros de configuração XML da aplicação. À primeira vista, pode parecer mais simples criar esta aplicação sem o Struts, utilizando um servlet e páginas JSP. Para principiantes, isso é provavelmente verdade. Com a experiência, no entanto, torna-se mais fácil desenvolver com o Struts. Muitas empresas impõem a metodologia Struts para o seu desenvolvimento web pelas seguintes razões:
- O Struts segue o modelo MVC
- Quando todos os programadores trabalham da mesma forma, a manutenção da aplicação torna-se mais fácil, pois dispõem de uma arquitetura padrão.