Struts Hibernate Curso

Versão 2.0 – Março - 2009
Revisada por Mauro de Souza Guimarães

_____________________Curso Struts & Hibernate______________

EMENTA DO CURSO
Ítem Descrição Página
1 Afinal: O que é o Struts e para que serve? 3
2 O padrão de arquitetura M-V-C (Model – View – Controller). Uma rápida revisão. 4
3 O mecanismo do M-V-C em uma aplicação Web 5
4 O mecanismo do M-V-C em uma aplicação Web, com o STRUTS. 6
CONFIGURAÇÃO DO AMBIENTE DE DESENVOLVIMENTO
5 Configuração do Ambiente com o Eclipse 3.x e TomCat 5.x 7
5.1 Instalando o conteiner Web TomCat 7
5.2 Instalando a IDE Eclipse 3.2 7
5.3 Plugando o Eclipse (Plugin do TomCat para o Eclipse 3.x) 8
5.4 Plugin Struts Console 8
6 Criando um projeto Tomcat com Sysdeo 11
7 Adicionando o Struts ao seu projeto 13
8 Rodando o primeiro projeto: logon (struts-blank.war) 15
SOBRE O STRUTS
9 Agora, os detalhes do mecanismo... 16
10 Analisando a aplicação "Register" para entender a função do struts-config.xml 16
11 Descrevendo os componentes envolvidos na aplicação web-struts "Register" 18
12 Parte do Arquivo struts 20
13 Descrição do ocorrido 21
14 Todos os componentes em detalhes 21
14.1 O arquivo descritor de distribuição, web.xml 23
15 O arquivo de recursos da Aplicação e Internacionalização (I18N) 24
16 Como copiar com os ActionForms 25
17 Declarando os ActionForms dentro do struts-config.xml 26
17.1 Jakarta Commons - BeanUtils 27
17.2 Como ligar com os ActionForwards 28
17.3 Como construir com os ActionMappings 29
17.4 Como trabalhar com objetos Action 30
18 Como exibir conteúdo dinâmico - TagLibs 33
18.1 Instalando as extensões da tag do Struts 33

19 Jakarta Struts Framework - Multiplos Arquivos de Configuração 37
20 Tiles Framework – Gerenciamento de Layouts 37
20.1 Habilitando o Tiles Framework 38
20.2 Usando o Tiles Framework 39
20.3 Definindo a página de layout 41
21 Jakarta Struts Framework – Validator 43
22 Request Processor 48

Interplan Soluções em Conectividade Ltda.
Avenida Presidente Vargas, 962 grupo 1414 – Centro – Rio de Janeiro. Tels: 21-3473-2210 / 21-2516-2257 / 21-9471-2330
site: www.interplan.com.br email: interplan@interplan.com.br
site: www.ensina.com.br email: treinamento@interplan.com.br

Página 2 de 140


1. Afinal: O que é o Struts e para que serve?
O Struts é um projeto "open-source" criado pelo consórcio Jakarta e tem como objetivo principal oferecer
facilidade de desenvolvimento de aplicativos Web com padrão Java Enterprise Edition (JEE). Oferece uma série
de serviços de infra-estrutura, tais como:

Controle de fluxo de requisições HTTP;
Internacionalização;
Formulários;
Validação;
Criação de elementos html.

Sendo o Struts considerado um "framework de desenvolvimento", o que o diferencia de uma API
convencional, conhecida como "Biblioteca de classes"?
Com uma API ou biblioteca de classes, você simplesmente utiliza fazendo chamadas às suas classes e
interfaces.
Em um framework de desenvolvimento, além da utilização de classes e interfaces, você também pode
estender suas funcionalidades e alterar comportamentos. Tudo isso é possível através de um modelo de trabalho
conhecido como "Framework".
Um framework tipicamente oferece serviços técnicos “automatizáveis”, como por exemplo:

Persistência de dados em bancos SQL;
Log de aplicativos;
E no caso do Struts, aplicativos Web MVC de alta qualidade.

A utilização dos serviços oferecidos pelo framework é feita através da extensão de classes,
implementação de
interfaces, utilização de Tag Libraries (quando Web) e criação de documentos de configuração, tipicamente XML.

Concluindo

Com a utilização do Framework Struts, o desenvolvedor pode se beneficiar de uma série de "facilidades"
que o framework oferece e se concentrar na "Lógica do Negócio", aproveitando os serviços de infraestrutura e dos
serviócs técnicos especializados descritos acima. Se o desenvolvedor tivesse que se preocupar com todas as
questões de segurança, validação, tratamento de formulários, fluxo de requisições e ainda, a lógica do negócio,
muito tempo e esforço seria dispendido.


Página 3 de 140


2. O padrão de arquitetura M-V-C (Model – View – Controller). Uma rápida
revisão.
O padrão de arquitetura M.V.C. é o mais utilizado atualmente para soluções Web JEE e está presente nas
principais soluções JEE de grandes empresas. Este padrão determina a divisão do aplicativo em três principais
partes:

Model: representa as entidades, operações e lógica do negócio;
View: representa visualizações utilizadas pelos usuários para interagir com os dados e processamento;
Controller: representa a camada que recepciona as requisições, aciona o modelo e responde para o
usuário através do despacho para uma view.

Sem dúvida alguma, podemos afirmar que as aplicações desenvolvidas utilizando o padrão MVC são
capazes de crescer sem qualquer dificuldade. A complexidade, ou o que chamamos de responsabilidade de
componentes, é dividida de maneira mais inteligente, propiciando fraco acoplamento entre camadas, garantindo
ao
desenvolvedor e ao projeto maior flexibilidade para mudanças na arquitetura do software.
O Struts aplica fortemente o padrão MVC sob a arquitetura JEE, o que faz com que ele tenha grande
credibilidade e flexibilidade para desenvolvimento de aplicações Web em Java. Veja no diagrama abaixo, o
relacionamento entre as camadas.


Página 4 de 140


3. O mecanismo do M-V-C em uma aplicação Web
Funciona assim:

A IDA...
VIEW
Um usuário digita uma URL, no browser. A página é localizada em um Servidor web, e este devolve para o
browser uma página que é, por exemplo, um formulário. Esta página , o formulário, representa a camada de
interface com o usuário: a camada View (visão). Ela interage com o usuário tanto na entrada, isto é, no momento
que o usuário está preenchendo um cadastro, ou acionando um Hiperlink dentro de um site de compras, quanto na
saída, isto é, quando o aplicativo apresenta uma outra tela com uma mensagem ou outra página com formulário.

CONTROLLER
Lembra do formulário preenchido pelo usuário , no texto anterior? Pois bem, este formulário é enviado
para o Servidor Web, através do protocolo HTTP, junto com um objeto "Request" , que leva junto todos os campos
do formulário preenchidos pelo usuário. Estes campos são apresentados a um "servlet" desenvolvido com a
missão de "descascar" os dados fornecidos pelo usuário na outra ponta da Web (browser cliente) além de
identificar "o que" o usuário quer com estes dados: Incluir ? Listar ? Excluir ? Filtrar ? Calcular ?. Este "Servlet" ,
além de "pegar" os dados, tem que identifica que "regra de negócio" tem que acionar para estes dados
"coletados". Dependendo de qual regra seja, este "Servlet" deve acionar as classes Java que foram desenvolvidas
para atender ao negócio. Este "servlet" está agindo como um Controlador (Controller). Esta é a camada de
Controle.

MODEL
A classe de negócio, acionada pelo Controlador, é uma classe especializada para exercer a função para a
qual ela foi escrita. Por exemplo, para o formulário enviado pelo usuário na camada de apresentação e cujos
dados foram "coletados" na camada de Controle, a camada de Modelo é onde estas classes de negócios "atuam".
Elas executam suas tarefas, podendo acessar os dados que estão guardados em "Banco de Dados", efetuar
cálculos...

E A VOLTA....
MODEL
A classe de negócios aí de cima, ao terminar sua tarefa, prepara os dados para serem enviados pelo
Controlador ao usuário que está esperando de frente para o Browser. Sendo assim , ao terminar suas atividades,
a classe de negócio "avisa" ao Servlet controlador que os dados já estão preparados. Aí se encerra a atividade da
classe de negócio. A camada de Modelo (MODEL), fica esperando a próxima demanda.

CONTROLLER
O Servlet Controlador, na camada de Controle, ao ser avisado pela camada de Modelo, através da classe
de negócio, que existem "dados" prontos para serem exibidos ao usuário, aciona uma página JSP (por exemplo)
que preenche e formata os dados para serem enviados ao Browser do cliente. Pronto. Agora que a página JSP já
está carregada com dados "novinhos" e formatados, a envia para o Browser do cliente, onde ele está
aflito,esperando..

VIEW
O usuário recebe os dados formatados, através de uma página JSP, e os apresenta no Browser.
O processo pode se repetir, indefinidamente.....


Página 5 de 140


4. O mecanismo do M-V-C em uma aplicação Web, com o
STRUTS.
Veja o diagrama abaixo:

Jakarta Struts Framework – Modelo MVC

3

Na figura acima, estão representadas as 3 camadas: Model – View – Controller.


Página 6 de 140


O mecanismo, agora, é o seguinte:

O cliente preenche o Formulário no Browser (repare a figura do LapTop onde está escrito Client
Browser).
Ao acionar o botão de “Submit”, um objeto "Request" (HTTPRequest = a solicitação com os dados do
formulário) é enviado para o Servlet Controlador na camada de Controle, representado pela classe
“ActionServlet”. O objeto “Request” leva os parâmetros do formulário, digitados pelo usuário.
O “ActionServlet” preenche automáticamente, uma classe chamada de "ActionForm", que é um
JavaBean, carregando os dados do formulário de entrada. Desta forma, os dados de entrada ficarão
disponíveis para as outras camadas do aplicativo, dentro do JavaBeans.
Baseado em algumas informações, o “ActionServlet” (Servlet Controlador) decide qual classe de negócio
será acionada. Estas classes serão acionadas por uma classe especial chamada de "Action" que
representa a lógica do negócio. Esta classe implementará, de certa forma, a Regra de Negócio. Esta
classe obterá da classe "ActionForm" (o JavaBean) os parâmetros do formulário inicial da camada de
Apresentação.
Ao final do processamento, a classe "Action" prepara a saída, indicando uma página JSP da camada de
Visão, preenchedo-a com os dados resultantes da lógica do negócio. Um outro objeto chamado de
"ActionForward" indica qual a página JSP será chamada para apresentar o resultado para o usuário.

5. Configuração do Ambiente com o Eclipse 3.x e TomCat 5.x
5.1. Instalando o conteiner Web Tomcat
1. Obtenha a instalação do Tomcat através do site tomcat.apache.org. Quando da elaboração deste material,
a versão disponível era a 5.5.16 (apache-tomcat-5.5.16.zip)

2. A instalação do Tomcat também é extremamente simples. Basta descompactar o arquivo zip no diretório
raiz, ou em uma pasta de uma das unidades de disco disponíveis, mantendo a estrutura de pastas.

3. Criar uma variável de ambiente CATALINA_HOME, apontando para o diretório que foi criado com a
descompactação do pacote Tomcat.

5.2. Instalando o Eclipse (Esta parte pode variar, dependendo da versão do Eclipse)
1. Obtenha a instalação do eclipse através do site www.eclipse.org/downloads. Quando da elaboração deste
material, a versão disponível era a 3.0 (eclipse-SDK-3.0-win32.zip)

2. A instalação do eclipse é extremamente simples. Basta descompactar o arquivo zip no diretório raiz, ou
em uma pasta de uma das unidades de disco disponíveis, por exemplo , o drive C: ou D:, tanto faz. Veja a
figura:


Página 7 de 140


Notar que a estrutura de diretórios deve ser mantida, portanto, a opção “Use folder names” deve ser
mantida checada.

3. Será criado o diretório "/eclipse" no qual você irá encontrar o executável eclipse.exe para iniciar o mesmo.

4. Para iniciar o eclipse, dependendo da sua versão, é apresentada uma sugestão para onde deverá ser
instalado o Eclipse, como mostra a figura abaixo:


Página 8 de 140


5. Nós iremos utilizar o padrão de diretórios que o Eclipse utiliza, isto é, sugerindo a instalação em
“C:eclipseworkspace”, que é padrão. O eclipse cria de forma automática uma pasta para armazenar todos
os projetos criados (uma workspace) opte pela pasta default marcando o checkbox correspondente e clicando
no botão OK Em outros momentos, o programador poderá escolher um diretório que seja mais prático,
dependendo de seu projeto.

6. Após a instalação, a estrutura de diretórios que se apresenta é a descrita na figura abaixo:

7. A tela inicial do eclipse será apresentada.

Plugin "Struts Console"

O Struts Console é um aplicativo que lhe permite editar de maneira visual o arquivo de configuração struts-
config.xml. Ele funciona como uma aplicação stand-alone (isolado, podendo ser executado isoladamente) ou
integrado ao Eclipse como um plugin.

1. Para instalar o aplicativo Struts Console, descompacte o arquivo
"struts-console-4.8.zip", que vem no CD do aluno. Será criado um diretório parecido com o abaixo:

Para rodar a aplicação fora do Eclipse, basta ir ao diretório "bin", e rodar o arquivo "console.bat" que
deverá apresentar a seguinte tela:


Página 9 de 140


Conforme dito anteriormente, o "Struts Console" é um editor do arquivo struts-config.xml".
Para que ele funcione o aluno deve acionar o "struts-config.xml", onde irá aparecer a seguinte tela:

Para instalar o plugin no eclipse basta copiar o diretório "com.jamesholmes.console.struts" no diretório
"eclipseplugins" e reiniciar o eclipse. A partir daí, toda vez que o arquivo "struts-config.xml" for clicado dentro
da aba “Package Explorer” do eclipse, será aberta uma tela do Struts Console, conforme ilustrado anteriormente.


Página 10 de 140


6. Criando um projeto no Tomcat
1. Agora o programador irá criar o ambiente do Projeto. Para isto vai selecionar as opções "File" > "New" >
"Project". Depois escolha “Tomcat Project” para criar uma estrutura já apropriada para aplicações Web, conforme
as figuras abaixo:

2. Em seguida, o Eclipse apresentará uma tela solicitando o nome do projeto. O aluno preenche e clica no botão
"Next". Observe que o botão que se apresenta indicado é o botão "Finish". MAS O ALUNO DEVE CLICAR
NO BOTÃO "NEXT".

3. Depois de informar o nome do projeto, deixe o nome do contexto (o nome que vem depois da porta 8080 na
URL digitada no browser) como o nome do projeto; deixe selecionada a opção “Can update server.xml file” , e na
opção “Subdirectory to set as web application root”, informe "/web", conforme figura abaixo:


Página 11 de 140


4.Estas ações irão criar um projeto com as devidas bibliotecas "servlet/jsp" provenientes do tomcat e irá criar um
diretório "src" para o código fonte, além de criar um diretório "web" para a raiz do seu web site.
Ao final , o seu projeto no eclipse deverá se parecer conforme a figura abaixo:


Página 12 de 140


7. Adicionando o Struts ao seu projeto
O pacote "struts-1.2.8.zip" fornecido no CD do aluno contém diversas aplicações web J2EE compatíveis
(arquivos com extensão.war), contidas na pasta "webapps". Uma delas é o struts-blank.war, que é uma aplicação
em branco, com todas as configurações necessárias para rodar o struts em uma aplicação web.

O Struts-Blank é distribuido como um arquivo do tipo WAR (Web Archive). Para iniciar a aplicação, tudo o
que o aluno precisará fazer é:
1) Copiar o arquivo "Struts-Blank.war" da pasta "webapps" do diretório struts-1.2.8 , criado com a
descompactação do arquivo struts-1.2.8.zip, fornecido no CD do aluno, para um local qualquer.
2) Um arquivo com extensão "war" pode ser lido com o "Winzip". Para isto, basta associar a extensão de
arquivo "war" ao aplicativo "WinZip".
3) Após isto, dê dois cliques no arquivo "Struts-Blank.war" . O "WinZip" abrirá uma janela. O aluno deverá
solicitar que o "WinZip" descompacte o "Struts-Blank.war" dentro do diretório "web" do Projeto recém criado no
Eclipse (projeto "logon" página 10), podendo sobrescrever os arquivos pré-existentes. Logo em seguida você deve
dar “refresh” na estrutura do seu projeto, o qual deverá agora parecer com a figura abaixo:

Logo em seguida você pode remover alguns
arquivos e diretórios que não serão necessários
nesse ambiente Eclipse:

/bin
/src
/web/WEB-INF/src/build.xml
/web/WEB-INF/src/README.txt
/web/WEB-INF/META-INF

O arquivo MessageResources.properties deve ser
movido do diretorio /web/WEB-INF/src/java para
/web/WEB-INF/src , o subdiretório java poderá ser
eliminado logo em seguida.

Para finalizar, a biblioteca principal do Struts, o arquivo "struts.jar", contido no diretório "/web/WEB-INF/lib" deve
ficar no classpath do seu projeto, para tal, clique com o botão direito no nome do seu projeto (nó), e selecione
“Properties/Java Build Path/Libraries/Add Jars…”, e selecione o arquivo struts.jar contido no diretório /web/WEB-
INF/lib , conforme figura abaixo:


Página 13 de 140



Página 14 de 140


8. Rodando o primeiro projeto: hello
O aluno poderá iniciar a execução do Tomcat, de dentro do próprio Eclipse, acionando a figura do gato que

está mais à esquerda:

O Eclipse irá carregar o Tomcat e o aluno poderá perceber isto, no final numa tela de “console”, como ilustrado
abaixo. Quando o aluno perceber a mensagem “INFO: Server startup in 11187 ms” ele saberá que o Tomcat
está carregado e pronto para ser utilizado.

Para ter certeza de que o servidor de Aplicação Web Tomcat está carregado e funcionando, o usuário
deverá carregar o Browser e digitar a URL (*):
http://localhost:8080/hello
Se tudo estiver correto, a seguinte mensagem aparecerá na tela de seu browser:

Welcome!
To get started on your own application, copy the struts-blank.war to a new WAR file using the name
for your application. Place it in your container's "webapp" folder (or equivalent), and let your
container auto-deploy the application. Edit the skeleton configuration files as needed, restart your
container, and you are on your way! (You can find the application.properties file with this message
in the /WEB-INF/src/java/resources folder.)


Página 15 de 140


9. Agora, os detalhes do mecanismo...

O Framework Struts inaugura o conceito de “Programação Declarativa", isto é, muitas informações
importantes são fornecidas sob a forma de tags XML, ao invés de criar classes de programas.
O arquivo “struts-config.xml” possui estas informações, como veremos adiante.
O “coração” do FrameWork Struts , são o ActionServlet e arquivo de configuração “struts-config.xml”. Este
último contém várias informações importantes e que determinam como o aplicativo se comporta e é consultado
pelo "ActionServlet" assim que ele for carregado.
Lembrando que todo Servlet, tem que residir em um conteiner, como o TomCat. Assim que o conteiner é
inicializado (TomCat) ele primeiro lê o descritor de distribuição, o arquivo web.xml que informa quais Servlets
devem ser carregados pelo conteiner. Desta forma, o "ActionServlet" é carregado automáticamente e fica na
memória esperando por alguma URL que acione o mecanismo. O arquivo web.xml deve indicar que o
"ActionServlet" será carregado. Isto é feito com o seguinte código :

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-mapping>
</servlet-mapping>
Desta forma, quando um usuário digitar qualquer caminho que termine em ".do" (que é mais utilizado pela
comunidade Struts), a solicitação (Request) com todos os dados preenchidos pelo usuário será enviado para
o "ActionServlet".
Quando um "ActionServlet" recebe uma solicitação, várias ações ocorrem até que um resultado seja
apresentado para o usuário, na "volta" do processo.
O "ActionServlet" é um Servlet. Ele não aparece no classpath da aplicação. Ele fica dentro do arquivo
struts.jar, este sim, referenciado no classpath da aplicação.

Importante !!
O "ActionServlet" , ao ser acionado, lê o arquivo struts-config.xml. Este arquivo contém diversas tags e
parâmetros que vão determinar como a aplicação vai se comportar. A seguir, iremos detalhar os principais
componentes do arquivo struts-config.xml.

10. Analisando a aplicação "Register" para entender a função do struts-
config.xml
Vamos examinar a aplicação "Register", fornecida no CD do aluno, para que possamos compreender
definitivamente, todo o processo que envolve desenvolver uma aplicação web, baseada no framework Struts.

O usuário digita: http://localhost:8080/register/Register.jsp

A tela seguinte será apresentada ao aluno. O aluno fornece um nome de usuário e uma senha. Depois o
usuário confirma a senha. Ao final do processo, aciona o botão "OK", que é o botão de "Submit". Não se
esqueçam que exite uma ação associada ao botão de "Submit" (botão "ok" na figura)


Página 16 de 140


Struts User Registration

Username:

Password:

Confirm:

ok

figura 12.1 página "register.jsp"

Ao pressionar o botão "ok", o padrão "register.do" é enviado para o Servlet. Este envio é feito pela
cláusula <form action="register.do"> que está presente no arquivo "Register.jsp".
O Servlet "ActionServlet" procura no arquivo "struts-config.xml" dentro da tag <action-mappings> por uma
tag <action> que possua uma cláusula "path" que possua a palavra "/register", que coincida com a palavra indicada na tag
action do arquivo Register.jsp. Não há a necessidade de se escrever no arquivo struts-config.xml, a palavra "register.do",
podendo ser desprezado o final ".do".
Bom, tudo começa quando o Servlet encontra (no struts-config.xml ), uma tag <action> com a cláusula "path =
/register" conforme pedaço do código destacado abaixo(parte do struts-config.xml)

O usuário digita um nome e depois preenche o campo senha. Após isto, deve re-digitar a senha. Caso a
senha esteja digitada de forma correta a seguinte mensagem aparece:

Registration Succeeded!

Try Another?

Se a senha for digitada de forma errada, esta outra mensagem aparece:

Registration failed!

Try Again?

O que ocorreu entre o aparecimento da página do formulário e a página com uma das mensagens?


Página 17 de 140


11. Descrevendo os componentes envolvidos na aplicação web-struts
"Register"
Para funcionar, e de forma resumida (mais à frente complicaremos mais um pouco) , serão necessários
criar os seguintes componentes:

Um ActionForm;
Um Action;
O arquivo struts-config.xml;
3 (três) páginas html (register.jsp; sucess.htm e failure.htm).

ActionForm
O ActionForm é um JavaBean que guardará os parâmetros fornecidos no formulário "register.jsp" que
são o "nome do usuário", "senha_1" e "Senha_2". É comum, dar-se o nome da aplicação, com o sufixo "Form"
para um ActionForm. Então , o nosso primeiro "ActionForm" se chamará "RegisterForm". Ele será uma classe
java, um JavaBean para ser mais exato. Esta classe, deve "estender" a classe org.apache.struts.ActionForm e
como já explicamos antes, este objeto captura os parâmetros do formulário trazido pelo Request. Para funcionar
corretamente, é necessário que o RegisterForm possua as variáveis de instância coincidindo com os nomes dos
campos do formulário de entrada, juntamente com os métodos getters e setters.

Este é o código da classe RegisterForm , o ActionForm da aplicação:

package app;

import org.apache.struts.action.ActionForm;

public class RegisterForm extends ActionForm {

protected String username;
protected String password1;
protected String password2;

public String getPassword1() {
return password1;
}
public void setPassword1(String password1) {
this.password1 = password1;
}
public String getPassword2() {
return password2;
}
public void setPassword2(String password2) {
this.password2 = password2;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}

Página 18 de 140


Action
Um Action é uma classe java que extende org.jakarta.struts.Action. Após o ActionServlet, preencher o
ActionForm (RegisterForm no nosso aplicativo) ele aciona um Action, entregando para ele o ActionForm
preenchido, para que ele, Action, valide os campos do ActionForm, depois decida quais outras informações de
negócios serão recuperadas/criadas/alteradas e no final do processamento, a classe Action retorna um outro
objeto chamado "ActionForward" (que indica um "caminho" de um recurso, podendo ser uma página JSP de
resposta, por exemplo) deve ser retornado ao ActionServlet. É comum, dar-se o nome da aplicação, com o sufixo
"Action" para um Action. Então , o nosso primeiro "Action" se chamará "RegisterAction".
Observar na listagem do Action que ele possui um método chamado execute( ...) que recebe referência
de vários objetos como ActionMapping, ActionForm, HttpServeltRequest e HttpServletResponse). Este método é o
coração do Action e ao final de sua execução, ele deve retornar um objeto "ActionForward".
Este é o código da classe RegisterAction o Action da aplicação:

package app;

import javax.servlet.http.*;
import org.apache.struts.action.*;

public class RegisterAction extends Action {

public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {

//Faça um cast para o form bean que voce criou
RegisterForm registerForm = (RegisterForm)form;

//Aplicar a regra do negocio
if (registerForm.getPassword1().equals(registerForm.getPassword2()))
{

//Retorne um ActionForward no caso de sucesso
return mapping.findForward("success");
}
else {
//Retorne um ActionForward no caso de falha
return mapping.findForward("failure");
}
}
}


Página 19 de 140

12. Parte do arquivo struts-config.xml, com as tags <action-mappings> e <action>



<action-mappings>
<action path="/register"
type="app.RegisterAction"
name="registerForm"
validate="true"
scope="request"
input="/register.jsp">
<forward name="success" path="/success.html" redirect="false" />
<forward name="failure" path="/failure.html" redirect="false" />
</action>

Explicando o mecanismo, as tags e parâmetros:

O arquivo struts-config.xml contém detalhes que o ActionServlet precisa saber para lidar com o Request
(solicitação) feitas à aplicação, via formulário de entrada (register.jsp)

<action path=“/register” = este é o caminho lógico da ação. No comando action do HTML
do formulário de entrada, deverá estar declarado um
"register.do". O ActionServlet procurará no “struts-config” por
uma entrada “action” de um register, sem o “.do”.

type=“app.RegisterAction” = é o nome da classe Action que será acionada pelo Servlet e
processará o objeto “Request” enviado. "app" é o nome do pacote
onde a classe RegisterAction se encontra

name=”registerForm” = nome do ActionForm (JavaBean) que estará associado ao
aplicativo. O ActionForm é a classe de mapeamento do
formulário, isto é, todos os dados do formulário de entrada que
possuem variáveis de mesmo nome no JavaBean, serão
copiados para as variáveis automáticamente.

validate="true" = esta cláusula indica que o método validate ( ) do ActionForm
será chamado após o ActionForm ser preenchido com os dados
do request (solicitação do usuário). Este método é usado como
validação superficial e retorna um objeto ActionErros no caso de
existir algum. Este objeto será gravado no contexto da solicitação.

scope="request" = O identificador do escopo (solicitação ou sessão) dentro do qual
o Form (actionForm) associado a este mapeamento, vai ser
criado. Neste exemplo, o registerForm.

input=“/Register.jsp”> = no caso de um erro de validação, esta é a página que será
apresentada ao usuário.


Página 20 de 140

<forward name=“sucess” path=“/sucess.htm”/> = No caso da variável “target” do código
acima ser igual a “sucess”, indica a
página que será apresentada ao usuário.

<forward name=“failure” path=“/failure.htm”/> = No caso da variávél “target” do código
acima ser igual a “failure”, indica a página
que será apresentada ao usuário.
13. Descrição do ocorrido
Quando o usuário "aponta" o browser web para http://localhost:8080/register/Register.jsp,
o conteiner TomCat se apresenta para receber como sempre faz com qualquer página JSP. As tags HTML da
página Register.jsp, são devolvidas ao Browser, o que produz a tela da página 19.
O usuário fornece um nome e duas senhas. Após isto, o usuário clica no botão "Ok".
O browser envia o conteúdo do formulário (nome e duas senhas) como uma solicitação http, que atinge o
Servidor.
O TomCat sabe através da leitura do arquivo "web.xml" que, pelo padrão ".do" ele deve entregar estes
dados para um ActionServlet, mais específicamente o "RegisterAction". Esta solicitação (request) é então
processada pelo "RegisterAction".
O "RegisterAction" lê o arquivo struts-config.xml procurando por uma tag <action> que possua a
cláusula "path" coincidindo com o padrão register.do como indicado no arquivo Register.jsp. Mas procura apenas
por "/register" não procurando pelo ".do"
Ao achar a tag <action>, o Servlet procura a cláusula "name" que aponta para o ActionForm (JavaBean)
que receberá os parâmetros do formulário de entrada. O ActionForm é o "RegisterForm".
Ao terminar de preencher o RegisterForm com os dados da entrada, o Servlet "ActionServlet" passa o
controle da execução para a classe Action, indicada na cláusula "type" dentro da tag <action> " e disponibiliza o
JavaBean (RegisterForm) para esta classe. No exemplo, é a classe "RegisterAction.
O método execute( ) desta classe é executado e ao final este método devolve um objeto do tipo
"ActionForward", fazendo uma referência ao nome "lógico" dele. Este nome "lógico" do ActionForward está
também registrado dentro do arquivo struts-config.xml e , lá, aponta para um arquivo "html" ou outro "Action".
Caso algum erro seja encontrado durante o processo, a cláusula "input" indica qual página a ser
chamada. No exemplo, a cláusula input aponta para “/Register.jsp”, indicando que chama novamente o
formulário de entrada.

14. Todos os componentes em detalhes
14.1 O arquivo descritor da distribuição, web.xml.
Como já vimos, o centro do framework é o ActionServlet, que é usado como Controlador. Geralmente
este arquivo não é alterado e muitas configurações de que este arquivo precisa , é feito via o arquivo web.xml.
Básicamente, existem dois componentes que precisam ser configurados via o web.xml: o ActionServlet e
as bibliotecas de tags do Struts.
Vamos apresentar o código de um arquivo web.xml com algumas considerações. Veja na página seguinte,
o arquivo web.xml da aplicação "Register".

Observe que existe um cabeçalho inicial que identificam o arquivo como um descritor de distribuição
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">


Página 21 de 140

Em seguida, dentro da tag <web-app> e </web-app> , exite toda a configuração do arquivo. Dentro da tag
<servlet> </servlet>, dá-se a configuração do Action Servlet

<web-app>
<servlet>
<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>
<load-on-startup>2</load-on-startup>
</servlet>

A próxima sessão, é utilizada para identificar as solicitações do struts, isto é, qual a forma que a
solicitação deve ser feita para que o Servlet seja acionado:

<servlet-mapping>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

A tag <servlet-mapping> indica que toda solicitação (request) que for chamada com o final ".do" servirá
para acionar o ActionServlet, devido ao padrão "*.do"
Para que a aplicação chame automáticamente o arquivo "register.jsp", devemos indicá-lo com a tag
<welcome-file-list> , conforme apresentado abaixo:

<welcome-file-list>
<welcome-file>register.jsp</welcome-file>
</welcome-file-list>

A fim de se poder usar as bibliotecas de tags do Struts, assunto que abordaremos mais à frente, é
necessário que que as configuremos aqui. Exitem 3 bibliotecas de tags do Struts, básicas: bean, html e logic.
Estas serão utilizadas pela maioria das aplicações, e em muitos casos substituirão completamente as tagas html e
facilitarão outras ações.
Se outras bibliotecas de tags fossem utilizadas pela aplicação, estas seriam configuradas neste mesmo
local, como tiles ( outro assunto mais adiante), conforme o código abaixo:
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-logic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-tiles</taglib-uri> Interplan Soluções em Conectividade Ltda.
<taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>interplan@interplan.com.br
site: www.interplan.com.br email:
</taglib>
</web-app>
Página 22 de 140

14.2. Agora o "web.xml" completo:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

<web-app>
<display-name>Struts Blank Application</display-name>


<servlet>
<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>

<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<url-pattern>*.do</url-pattern>
</servlet-mapping>


<welcome-file-list>
<welcome-file>register.jsp</welcome-file>
</welcome-file-list>

<!—Descritores da Biblioteca de Tags do Struts -->
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-logic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/tags/struts-tiles</taglib-uri>
<taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>
</taglib>
</web-app>


Página 23 de 140


15. O arquivo de recursos da Aplicação e Internacionalização
(I18N)
O Struts possui um sistema de mensagem muito flexível. Se o programador precisar desenvolver um site
com mensagens em várias línguas , utilizará este arquivo de recursos para, fácil e rápidamente criar várias
versões de mensagens e labels, uma para cada língua desejada.
A isto chama-se "Internacionalização" da aplicação ou "Localização" da aplicação. O mecanismo de
internacionalização é o que garante que uma aplicação irá apresentar-se no idioma local do usuário.
O Struts utiliza arquivos de propriedades para armazenamento de mensagens em diferentes idiomas.
O arquivo de mensagem , geralmente fica localizado em qualquer lugar debaixo do diretório WEB-INF.
Muitos programadores o colocam dentro de WEB-INF/classes, dentro de um pacote , que é um diretório.
O "pacote" pode se chamar "resources". Dentro deste pacote, existirão os arquivos "properties"
(java.util.Properties). Observar que o uso do pacote NÃO É OBRIGATÓRIO, podendo o arquivo de propriedades,
MessageResources, ficar localizado na raiz do diretório WEB-INF. O uso do pacote serve para organização.
O arquivo de propriedades que normalmente é utilizado pelos programadores Struts é o
MessageResources.properties. Ele é um arquivo que pode ser editado por qualquer editor de texto (até o
NotePad) e é constituído por um par de "chave-valor" em cada linha.
No arquivo descritor de distribuição web.xml, utiliza-se a tag <init-param> para registrar o arquivo de
propriedades e o pacote onde ele reside, conforme ilustrado abaixo:

<init-param>
<param-name>application</param-name>
<param-value>resources.MessageResources</param-value>
</init-param>

Observe que na tag <param-value> estamos registrando o pacote resources antes do nome do arquivo
MessageResources.
Isto indica para o Struts que ele deverá buscar, debaixo do diretório/pacote "resources", um arquivo
MessageResources.properties

Para cada novo idioma deve ser criado um arquivo MessageResources_yy_XX.properties, onde yy é a
sigla da língua e XX, a sigla o País, por exemplo MessageResource_fr_FR.properties, informa que o conteúdo das
mensagens é da lingua francesa da FRANÇA, ou MessageResource_es_ES.properties , informa que o conteúdo
das mensagens é da lingua espanhola da ESPANHA

Também podemos informar no arquivo Struts-config.xml, que existe um arquivo de propriedades para
internacionalização, utilizando a tag <message-resources> . Desta forma:

<message-resources parameter="resources.MessageResources" />

Para atribuir qual a localização (java.util.Locale) atual do usuário à sua respectiva HttpSession, podemos inserir o
seguinte código no método execute de um Action:

this.setLocale(new java.util.Locale(“en”, “US”), request);
O qual irá atribuir a linguagem e país do usuário para inglês dos Estados Unidos. A partir de então o usuário irá
acessar o site nesta linguagem, caso o recurso exista.


Página 24 de 140


16. Como copiar com os ActionForms
• ActionForms são JavaBeans utilizados para encapsular e validar os parâmetros do objeto "Request".
• Para cada parâmetro do request que se deseja obter, será necessário criar métodos getters e setters.
• Grande parte dos parâmetros de um formulário que é enviado para o Servidor, deve ser "validado", antes
de ser submetido para o nível de negócio. Se um campo deve conter um número, será nosso trabalho
garantir que de fato, este campo contenha um número, do contrário deveremos emitir um alerta de erro e
não deixar o campo ser enviado ao Servidor.
• Para realizar esta e outras tarefas, o framework Struts todas as entradas do formulário serão transferidas
automáticamente para um componente do tipo ActionForm para que estas sejam validadas.
• Após esta validação, estas entradas serão enviadas para o Action (uma classe de negócio, explicada
mais adiante), dentro de um JavaBean preenchido e organizado, que é a classe ActionForm.
• Para efetuar a validação dos campos, uma classe ActionForm disponibiliza outros dois métodos (além
dos getters e setters) a serem sobrescritos: validate( ) e reset( ).
• O método validate( ), serve para a validação do campos do formulário, antes de transmitir para o Action.
• Observe que dentro deste método, um objeto “ActionErros” (com a letra “S” no final) é instanciado.
• Objetos ActionErros são coleções de ActionErro (no singular). Este último são erros que podem
acontecer.
• Objetos ActionErros são HashMap que armazenarão um par “Chave x Valor”.
• Este objeto será usado quando um Erro for encontrado durante a validação dos campos.
• Encontrando um Erro, este será adicionado à HashMap, da seguinte forma:
• A ”chave”, é o nome do campo que está sendo testado.
• O “valor”, é uma instância de “ActionErro” cujo parâmetro será a descrição do erro. Esta e todas as
descrições de erros que o aplicativo reportar estarão registradas no arquivo ApplicationResources .
• O arquivo ApplicationResources fica armazenado no diretório WEB-INF da aplicação.
• O método validate normalmente é utilizado para implementação de regras de validação dos dados
informados nos campos do formulário.
• O método reset( ), serve para a iniciar as propriedades do JavaBean (ActionForm), antes que ele seja
preenchido com os valores vindo do formulário.
Exemplo do método validate () que está inserido no ActionForm:


Página 25 de 140

Observe no código abaixo:

1) O método retorna um objeto ActionErrors, que é uma coleção de objetos Error (linha 183)

2) Ao ser detectado o erro (linha 189), este será adicionado à coleção de erros (errors.add( ) ),
passando o nome do campo (username) como chave da coleção de erros. O valor
correspondente à chave, é a instância de uma classe "ActionMessage" (linha 190) com o valor
que deve ser procurado no arquivo ApplicationMessage, que é por exemplo,
"error.username.required".

17. Declarando os ActionForms dentro do struts-config.xml

Para ser reconhecido pelos componentes do framework, os ActionForms (os JavaBeans vitaminados)
precisam estar registrados dentro do arquivo de configuração struts-config. Isto é feito conforme exemplo
abaixo:

<form-beans>

<form-bean
name="logonform"
type="app.LogonForm"/>


<form-bean
name="logonForm"
type="org.apache.struts.action.DynaActionForm">
<form-property
name="username"
type="java.lang.String"/>
<form-property
name="password"
type="java.lang.String"/>
</form-bean>

</form-beans>

Observe que a tag inicial é <form-beans> com "s" no final, indicando que a partir desta tag, colocaremos
todos os beans da aplicação.
Para cada elemento ActionForm da aplicação, inicamos uma tag <form-bean> no singular, conforme
ilustrado acima. Observe que temos dois tipos de JavaBean: um ActionForm e um DynaActionForm.
O primeiro, ActionForm, é um JavaBean, cujas propriedades são descritas na própria classe e o segundo,
utiliza a declaração das propriedades no próprio arquivo struts-config.xml, como ilustrado acima.
O programador deverá criar sua própria classe ActionForm, dando nome a ela e fazendo-a estender a
classe ActionForm (org.apache.struts.action.ActionForm), como ilustrado abaixo:


Página 26 de 140


17.1 Jakarta Commons - BeanUtils
O Projeto Jakarta Commons

• Projeto Open-Source da Apache Software Foundation
• Conjunto de componentes reutilizáveis em Java
• Componentes evoluídos, testados e seguros
• Soluções para tarefas específicas
• Estimula a padonização do código
• O programador se concentra na regra do negócio
Commons BeanUtils

• Manipulação dinâmica de Beans
• Clonar Beans
• Obter propriedades dinamicamente
• Copiar propriedades
• Comparar/Classificar Beans


Página 27 de 140


Uma excelente maneira de colocar os dados ActionForm em outros JavaBean é usar a reflexão.
Inicialmente, a refelexão tinha uma desvantagem no desempenho, mas cada versão da JVM, tem
reduzido isso.
Você pode adcionar alguns métodos simples a uma classe de base ActionForm e facilitar a
transferência dos dados para, e , a partir de qualquer outro componente usando a reflexão. Os métodos
são apenas componentes em torno dos métodos da classe BeanUtils usados em outro lugar no
framework. O ActionServlet usa BeanUtils para preencher os ActionForms a partir da solicitação http.
O pacote Common BeanUtil, usado pelo Struts 1.1 , fornece uma conversão do tipo muito boa.
Se vc estiver usando a reflexão para transferir seus próprios dados, recomendamos importar o pacote
Commons BeanUtil, independentemente de qual versão do Struts está usando (1.0 ou 1.1).
O melhor método de transferência de dados completo é o BeanUtils.copyProperties.
Eis como usar o copyProperties para preencher seu componente a partir de outro:

BeanUtils.copyProperties(this, source);

O método copyProperties, aplicará automáticamente qualquer String nas conversões do tipo nativo em
qualquer direção. O novo copyProperties facilitará a "ida e volta" de seus ActionForms e dos
componentes de negócio: Veja o exemplo abaixo:

BeanUtils.copyProperties (myBusinessBean, myActionForm);
myBusinessOperation(myBusinessBean);
BeanUtils.copyProperties(myActionForm, myBusinessBean);

O código neste fragmento transfere as propriedades String em myActionForm para os tipos nativos em
myBusinessBeans, permite que a operação de negócio atualize os valores e então transfere os tipos
nativos de volta para String myActionForm

17.2 Como ligar com os ActionForwards
O que eles fazem?

• Muito bem depois da entrada pelo formulário ter sido passada para o ActionServlet e este chamar o Action
entregando-lhe um ActionForm repleto de informações, o Action, poderá perguntar ao final de ter
terminado sua tarefa com sucesso:

"Tudo bem. A operação teve sucesso.E agora? O que devo fazer?"

• Neste momento, o framework struts lança mão de um objeto ActionForward para indicar qual a página
JSP ou que outro Action será utilizado para transferir o controle da aplicação.

• Todas as JSPs que serão utilizadas como mecanismo de apresentação resultante do processamento de
uma ou mais classes Action, deverão ser mapeadas no arquivo struts-config.xml, desta forma:

A colocação da barra
no início do path é
fundamental!

Página 28 de 140


• Diferentemente do exemplo acima, é possível fazer com que o mapeamento da JSP esteja disponível para
toda a aplicação, de forma GLOBAL. Isto é útil para páginas de "erro" e "login" por exemplo

• A tag forward, vai fazer o redirecionamento “lógico” para as páginas da camada de “Apresentação”.

• O parâmetro name, indica o nome Lógico.

• O parâmetro path, indica o mapeamento Físico.

Acompanhe no exemplo abaixo. Ele é um trecho do arquivo struts-config.xml. Nele podemos observar na
linha 141, um forward indicando que a página Welcome.jsp, no diretório "pages" referente ao contexto , deve ser
apresentada assim que o URI "logon.do" for aplicado pelo browser. Da mesma forma, na linha 143, podemos
observar uma tag <action cujo path é igual a "/logonsubmit", sugerindo que a URI aplicada pelo browser é
"logonsubmit.do".

Observe também outra forma de se apresentar o elemento Actionforward: na linha 149, ao voltar da
execução da classe de negócio LogonAction caso o método execute( ) do Action encaminhe de volta ao Servlet
para procurar um ActionForward com o nome lógico de success, o fluxo de execução do programa será desviado
para outro Action : o welcome.do. O professor deve explicar que, dentro do struts-config.xml, deverá existir uma
outra tag <action> , cujo elemento path deverá ser igual a "/welcome"....

17.3 Como construir com ActionMappings
Um objeto do tipo ActionMapping (org.apache.struts.action.ActionMapping) está associado a um URI
(identificador de um recurso no Servidor). Quando um usuário digita uma informação no browser ou clica num
hyperlink que está associado a um padrão "*.do" do struts, o servlet (ActionSerlvet) vai ao arquivo struts-
config.xml, para procurar um objeto do tipo ActionMapping (tag <action) cujo parâmetro path coincida com o
padrão, sem o ".do" (como vimos anteriormente).
Os objetos ActionMapping ficam catalogados dentro da tag <ActionMappings, que é uma coleção de
ActionMapping.


Página 29 de 140

Já vimos na página 24 as principais propriedades dos objetos ActionMapping:

path type
name validate
input scope
forward action

A história é a seguinte: O Servlet (ActionServlet) ao ser acionado, analisa o URI digitado ou fornecido pelo
browser e tem que carregar uma classe de negócio, que é uma classe Action (org.apache.struts.action.Action).
Para esta classe Action, é fornecido (disponibilizado o acesso) um objeto ActionMapping, que fornece todas as
informações necessárias para o fluxo de execução da aplicação:

Indica a classe Action a ser carregada pelo Servlet – através do parâmetro "type"
Indica qual o JavaBean (classe FormAction) deve ser carregado – através do parâmetro "name"
Indica se tem que fazer a validação dos campos do formulário – parâmetro validate = true.
Indica qual classe chamar caso ocorra algum erro na validação – parâmetro "input"
Indica o escopo (área que o servlet usa para trocas de informações) onde o formulário será criado.

17.4 Como trabalhar com objetos Action
Os objetos Action representam a força de uma aplicação Struts, e onde os desenvolvedores web passam
grande parte de seu tempo.
As principais responsabilidades de um Action são:
o Acessar a camada de negócio
o Preparar os objetos de dados para a camada de apresentação
o Lidar com os erros que apareçam nestas ações

O ActionServlet, ao ser acionado (quando o container web for carregado, ele lê o arquivo web.xml que
indica qual o servlet carregar, lembra?) analisa a URI digitada ou informada pela cláusula action do HTML que
deve indicar um nome com extensão “.do” , por exemplo, “Login.do”
Ao receber esta solicitação, o ActionServlet, vai consultar o arquivo “struts-config.xml” para procurar uma
tag Action ( <action ) que tenha uma entrada /Login (sem o “.do”) como indicado no parâmetro "path".
Na verdade, o programador vai escrever uma classe de negócio que estende uma classe Action,
colocando o sufixo "Action" no nome da classe, como por exemplo, "LoginAction" ou "ProcessarPedidoAction". Isto
é uma recomendação.
As classes Action possuem um método execute (na versão struts 1.1) que deverá ser sobrescrita pela
implementação da subclasse de Action. Abaixo um exemplo de uma classe Action que trabalha com HttpServlets:


Página 30 de 140

import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

import modelo.*

import org.apache.struts.action.*;

public class CadastroAction extends Action {

public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) throws Exception {

ServletContext appContext = request.getSession().getServletContext();
if (appContext.getAttribute("bairros")==null) {
Collection bairros= Bairro.consultar();
appContext.setAttribute("bairros", bairros);
}

return mapping.findForward("sucesso");
}
}

Método execute (..)
Observe que a classe CadastroAction, estende a classe Action e possui o método execute(...).

Observe também que, os parâmetros do método execute são os objetos ActionMapping, ActionForm,
HttpServletRequest e HttpServletResponse. Desta forma, a classe Action poderá dispor de todos estes objetos
para trabalhar e obter os resultados da camada de negócio.

Então, resumindo, o ActionServlet chama o Action, executando o método execute (...).

O papel do Action é servir como uma espécie de "adaptador" entre os níveis da "web" e a camada de
negócio.

Para isto, o Action pode dispor do objeto ActionForm, que é passado como parâmetro. Lembrem-se de
que o objeto ActionForm possuem os parâmetros do formulário e ficam desta forma, disponíveis para o Action.

Separar as camadas
IMPORTANTE !!! IMPORTANTE !!!!! IMPORTANTE !!! IMPORTANTE !!!!! IMPORTANTE !!!!! IMPORTANTE !!!!!

É importante EVITAR colocar qualquer lógica de negócio na própria class Action. A classe Action deve
simplesmente reunir qualquer dado que os métodos de negócio e classes Action precisarem, e transmiti-los. Os
métodos de negócios deverão estar numa classe separada, que o Action possa chamar.
Na realidade, não se deve implementar as “Regras de Negócio” nas classes Action, pois isto aumenta em
muito o “acoplamento” entre as camadas de Modelo (Regras de Negócio) e a
camada de Controle (ActionServlet e Action).
O que deve ser feito é que outras classes extendam Action e executem o método execute( ). Este
método sim, é que deve chamar as classes que iremos construir e que implementam as regras de negócio

Tratamento de Exceções
As classes Action também detectam os erros que possam acontecer. O processo envolve a utilização de
dois objetos: ActionMessages e ActionError. Este assunto será coberto e apresentado em exemplos em alguns
capítulos à frente.


Página 31 de 140

As classes Action também executam o tratamento de exceções. Para isto, a fim de tratar uma exceção de
uma maneira consistente em todos os objetos Action, o programador poderá registrar um ExceptionHandler com o
arquivo de configuração do Struts, o struts-config.xml.
Para registrar uma Exceção, precisará fornecer o tipo Exception, a chave do recurso da mensagem e o
caminho da resposta, como ilustrado a seguir:

<exception
type="org.apache.struts.webapp.example.ExpirePasswordException"
key="expired.password"
path="/changepassword.do"/>

Actions roteiam o Controle
Como vimos anteriormente, os objetos ActionForwards podem definir os "lugares aonde ir", mas é o
objeto Action que seleciona qual ActionForward deve ser executado. O ActionForward define o "para onde";o
objeto Action define o "quando".
A maneira mais comum de uma classe Action selecionar um envio é através do método findForward do
ActionMapping, desta forma:

return mapping.findForward("sucesso");

DispatchAction
Uma estratégia comum entre os desenvolvedores Struts é usar a mesma classe Action para lidar com
várias tarefas afins.
Um bom exemplo é executar as operações CRUD (create, Read, Update e Delete) básicas em um registro
de dados.
Como estas operações tem muito em comum, poderá ser mais simples mantê-las em uma mesma classe.
Com os DispatchAction (org.apache.struts.action.DispatchAction) os desenvolvedores poderão agrupar diversos
métodos em um único Action.

Vamos supor que nossa classe "gravacaoDispatchAction" possuísse os seguintes métodos:

public ActionForward create (ActionMapping mapping, ActionForm form,

public ActionForward read (ActionMapping mapping, ActionForm form, HttpServletRequest
request, HttpServletResponse response) throws Exception {

public ActionForward update (ActionMapping mapping, ActionForm form,

public ActionForward delete (ActionMapping mapping, ActionForm form,


Página 32 de 140

O arquivo de configuração Struts poderia criar uma entrada como esta:

<action.
path="/registrarDados"
type="app.gravacaoDispatchAction"
name="dataForm" o parâmetro "parameter" indica qual método será
scope="request" chamado na classe DispatchAction
input="data.jsp"
parameter="method"/>

E para acessar o método "update" na classe "gravacaoDispatchAction" deveremos fazer:

http://localhost/app/dataRecord?method=update

18. Como exibir conteúdo dinâmico - Tag Libs
O Framework Struts disponibiliza algumas bibliotecas de tags. As mais usadas são: html, bean e logic .

html Tags usadas para criar formulários de entrada padrão HTML que podem interagir com o
frameowrk Struts e as tags HTML afins

bean Tags úteis ao acessar os JavaBeans e suas propriedades, assim como ao definir novos
componentes

logic Tags para gerenciar a geração condicional de saída, fazer um loop nas coleções de
objetos para uma geração repetida da saída e o gerenciamento de fluxo da aplicação

18.1 Instalando as extensões da tag do Struts
• Assim como qualquer outra biblioteca de tags, as existentes no Struts precisam ser declaradas no descritor
web.xml da aplicação, desta forma:


Página 33 de 140

• Na página "jsp", deve ser colocada a diretiva taglib conforme abaixo:

• Tem que existir estas diretivas no início da página
• Os parâmetros prefix, indicam de que forma devemos colocar na página HTML ,por exemplo:
< bean:write ....
< html:select...

18.2 Quais são as TagLibs ?
• Bean tags definir novos beans (em qualquer escopo) a partir de uma variedade de fontes e para imprimir beans
e suas propriedades na resposta :

Exemplo: <bean:write name="user“ property="fullName"/>
<bean:message key="index.title"/>

Esta instrução, <bean:write name="user“ property="fullName"/>, indica que , no tempo de execução,
apresentará “ali, no local onde a instrução está”, o FullName de “user”, que é uma propriedade do JavaBean.

Vejam as Bean Tags, na tabela abaixo:

Nome da Tag Descrição
cookie Define uma variável baseada no cookie especificado no request.
define Define uma varíavel para referenciar um bean ou propriedade específica.
header Define uma variável para referenciar um header específico do request
include Carrega a resposta de um request e disponibiliza o mesmocomo um bean.
message Processa uma mensagem de internacionalização e disponibiliza como uma string.
page Expõe um item específico do contexto da página como um bean.
parameter Define uma variável que faz referência um parameter específico do request.
resource Carrega e disponibiliza como um bean um recurso.
size Define um bean com o total de elementos de uma Collection ou Map.
write Exibe o valor de uma propriedade específica de um bean.


Página 34 de 140


• HTML tags para ajudar a montar páginas JSP mais rapidamente, principalmente "forms"
<html:link page="/editRegistration.do?action=Create">
<html:hidden name=“phone">Na tag acima, <html:link page="/editRegistration.do?action=Create"> está
sendo passado o parâmetro Create por “Query String”.
• A tag <html:link /> é equivalente ao href do HTML.

Vejam as html Tags, na tabela abaixo:

button Gera um botão html button
cancel Gera um botão html cancel
checkbox Gera um checkbox html
errors Imprime a coleção de erros
file Gera um campo do tipo file html
form Define um form html
frame Gera um elemento HTML frame
hidden Gera um campo html hidden (oculto)
html Gera a tag html
image Gera um input tag do tipo image
img Gera uma img html tag
javascript Utilizado para processamento de regras de validação do Validator no lado cliente.
link Gera um elemento html link
option Gera um elemento select option
password Gera um elemento input password
radio Gera um elemento do tipo radio button
reset Gera um elemento do tipo reset
select Gera um elemento do tipo select
submit Gera um elemento do tipo submit
text Gera um input do tipo text
textarea Gera um elemento do tipo textarea


Página 35 de 140


• Logic tags para fazer um pouco de lógica sem scriptlets, apenas através de parâmetros
apropriados
Exemplo de uma logic tag, usando todas as quatro propriedades comuns

<logic:iterate scope="request" name="result" property="collection" id="row" >

</logic:iterate>

Este exemplo informa para examinar o contexto da solicitação (scope="request"), para obter um componente,
denominado "result" (name="result"). Ao encontrar estes componente, recupera uma propriedade dele que é
uma coleção (property="collection), fazendo por exemplo um "getCollection". Então, faz uma iteração nesta
coleção (percorre a coleção) e exibe cada elemento desta, colocando cada elemento na variável "row"
(id="row")

Vejam as logic Tags, na tabela abaixo:

empty Executa o conteúdo da tag se a variável testada for null ou um string vazia.
equal Executa o conteúdo da tag se a variável testada for igual ao valor especificado.
forward Direciona o controle do fluxo de navegação para o ActionForward especificado.
greaterEqual Executa o conteúdo da tag se a variável testada for igual ou maior ao valor especificado.
greaterThan Executa o conteúdo da tag se a variável testada for maior do que o valor especificado.
iterate Executa o corpo da tag até o tamanho da collection especificada.
Executa o conteúdo da tag se a variável testada for igual ou menor do que o valor
lessEqual
especificado.
lessThan Executa o conteúdo da tag se a variável testada for menor do que o valor especificado.
Executa o conteúdo da tag desde de que a string informada contenha o trecho procurado.
match
(indexOf)
notEmpty Executa o conteúdo da tag se a variável testada não for um valor nulo ou vazio.
notEqual Executa o conteúdo da tag se a variável testada não for igual ao valor especificado.
notMatch Executa o conteúdo da tag se a variável testada não for uma substring da string principal.
notPresent Executa o conteúdo da tag se o valor informado não estiver presente no request.
present Executa o conteúdo da tag se o valor informado estiver presente no request.
redirect Gera um http redirect.


Página 36 de 140

Struts Hibernate Curso

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (9)

Semelhante a Struts Hibernate Curso

Semelhante a Struts Hibernate Curso (20)

Mais de Carlos Antonio Castro Oliveira

Mais de Carlos Antonio Castro Oliveira (10)

Struts Hibernate Curso