Tutorial Bsico do Framework Struts 2: Passo-a-passo

Traduzido por http://spigandoeaprendendo.wordpress.com

Parte 1 Introduo ao Framework Struts 2 ............................................................................................................... 3
Introduo ao Framework Struts 2 ............................................................................................................................... 3
A Arquitetura do Struts 2 .............................................................................................................................................. 3
Ciclo de vida do Processamento da Requisio ............................................................................................................ 4
Suporte AJAX no Struts 2 ............................................................................................................................................... 4
Comparao do Struts 1 e Struts 2 ................................................................................................................................ 5
Parte 2 - Tutorial: Criando uma aplicao Struts 2 no Eclipse .................................................................................. 5
Coisa que ns precisamos ............................................................................................................................................. 5
Nosso Objetivo .............................................................................................................................................................. 6
Primeiros Passos ............................................................................................................................................................ 6
Mapeamento o Struts2 no WEB.xml ............................................................................................................................. 8
A classe Action ............................................................................................................................................................... 9
O ResourceBundle .......................................................................................................................................................10
O JSP ............................................................................................................................................................................11
Login.jsp ...................................................................................................................................................................11
Welcome.jsp ............................................................................................................................................................12
O arquivo struts.xml ....................................................................................................................................................12
Quase pronto...............................................................................................................................................................14
Toque final ...................................................................................................................................................................14
Isso tudo pessoal ......................................................................................................................................................16
Download do cdigo fonte ..........................................................................................................................................16
Parte 3 Tutorial do Framework de validao do Struts2 com Exemplo ...............................................................17
Introduo ao framework de validao do Struts2 .....................................................................................................17
Escopo dos Validadores (Validators Scope) ................................................................................................................17
Primeiros passos ..........................................................................................................................................................18
Adicionando a lgica de validao ..............................................................................................................................22
Validao do lado cliente ............................................................................................................................................23
Isso tudo pessoal ......................................................................................................................................................24
Download do Cdigo Fonte .........................................................................................................................................25
Parte 4 - Tutorial do Plugin Struts 2 Tiles com exemplo no Eclipse ................................................................................25
Introduo ao Tiles 2 ...................................................................................................................................................25
Layout da nossa Aplicao ..........................................................................................................................................26
Arquivos JAR requeridos .............................................................................................................................................26
Configurando o Tiles no web.xml ................................................................................................................................26
Criando os JSPs ............................................................................................................................................................28

Modificaes no Struts.xml .........................................................................................................................................29

isso ai pessoal ...........................................................................................................................................................31
Download do cdigo fonte: Clique aqui para fazer o download do cdigo fonte (sem os JARs) (11KB) ....................32
Parte 5 Tutorial de Interceptadores (Interceptors) do Struts2 com Exemplo ......................................................32
Interceptadores do Struts 2: Fundamentos ................................................................................................................ 32
Nossa Meta..................................................................................................................................................................33
Criando o Interceptador de Log ..................................................................................................................................33
Configurando o interceptador no struts.xml .............................................................................................................. 34
Isso tudo pessoal ......................................................................................................................................................35
Download do cdigo fonte ..........................................................................................................................................36
Parte 6 Tutorial de Upload e Gravao de Arquivos do Struts 2 com Exemplo .................................................. 36
Arquivo JAR Necessrio ...............................................................................................................................................36
Primeiros passos ..........................................................................................................................................................37
Os JSPs .........................................................................................................................................................................39
Entrada no Struts.xml ..................................................................................................................................................40
Isso tudo pessoal ......................................................................................................................................................41
Download do cdigo fonte ..........................................................................................................................................42
Parte 7 (Final) Tutorial de Ajax no Struts 2 com Exemplo ....................................................................................43
Suporte AJAX no Struts 2 .............................................................................................................................................43
Exemplo AJAX: Ajax Drop Down (Combobox) do Struts2...........................................................................................43
Passo 1: Adicionar o arquivo JAR.............................................................................................................................43
Passo 2: Criar a classe action do AJAX .....................................................................................................................44
Passo 3: Crie o JSP ...................................................................................................................................................45
Passo 4: Criando a entrada no Struts.xml ............................................................................................................... 46
Isso tudo pessoal ......................................................................................................................................................47
Download do cdigo fonte ..........................................................................................................................................47
Concluso ....................................................................................................................................................................47

Parte 1 Introduo ao Framework Struts 2

Ento vamos comear a parte 1 de uma srie de 7 partes, Nestes tutoriais ns vamos discutir a Introduo
ao Framework Struts2, framework de validao, os interceptadores no Struts2, plugin Tiles e essa
aplicao com exemplo, um exemplo de upload de arquivo e exemplo de Ajax do Struts2.
I

Apache Struts 2 um framework elegante e extensvel para criao de aplicaes web em java. O
framework projetado para simplificar todo o ciclo de desenvolvimento, desde a construo, implantao,
manuteno de aplicaes ao longo do tempo.
Apache Struts2 foi originalmente conhecido como WebWork 2. Aps trabalhar independentemente por
vrios anos, as comunidades WebWork e Struts juntaram foras para criar o Struts2. Essa nova verso do
Struts mais simples de usar e mais prximo de como o Struts sempre pretendia ser.
Struts 2 um framework pull-MVC. Isto , os dados que so mostrados ao usuro tem que ser puxado da
Action.
Struts2 suporta configuraes baseadas em anotao que mais fcil de criar e mais intuitiva. Classe action
no Struts 2 atua como model na aplicao web. Ao contrrio do Struts, a classe action do Struts 2 so
simples objetos POJO assim slimplificando o teste do cdigo. Struts2 tambm bem com poderosas APIs
para configurar Interceptadores que reduzem muito o acoplamento na aplicao. A parte de view do Struts 2
altamente configurvel e suporta diferentes result-types como Velocity, FreeMarker, JSP e etc.
A

A Arquitetura do Struts 2 baseado no framework WebWork 2. Isto influncia as tecnologias JEE Standard
como Java Filters, JavaBeans, ResourceBundles, Locales, XML etc nesta arquitetura.
Abaixo segue o diagram do framework.

Imagem: struts.apache.org

1. O ciclo de vida normal do

comea quando a requisio enviada pelo cliente. Isto resulta na invocao
container que por sua vez passa atravs da cadeia de
padro.
do
para determinar se uma
2. O filtro FilterDispatcher que chamado consulta o
deveria ser invocada.
3. Se o
encontra uma
a ser invocada, o
delega controle ao
.
l o arquivo de configurao como o struts.xml.
cria uma instancia da classe
4. O
e delega o controle.
responsvel pela implementao padro de comando. Ela invoca os
5.
(Interceptadores) um por um (se necessrio) e ento invoca a
.
retorna, o
responsvel por procurar o resultado da propriedade
6. Uma vez que a
mapeada no struts.xml.
associada com o cdigo resultado da
so executados de novo na ordem contrria e a resposta retornada para o
(Na
7. Os
maioria dos casos ao FilterDispatcher). E o resultado ento enviado para o
container que por
.
sua vez o envia de volta ao
s

O ciclo de vida do processamento da requisio do framework Struts2 bastante discutida na sesso acima,
onde vimos a arquitetura do framework Struts 2.
1. A requisio gerada pelo usurio e enviada ao
container.
container invoca o filtro
que por sua vez determina a ao apropriada.
2.
so aplicados ante de chamar a
. Interceptors executam tarefas como
3. Um por um dos
,
,
,
e etc.
4.
executada e o
gerado pela
.
renderizada na view (
, etc) e o resultado retornado ao usurio.
5. A sada da
S

AJAX um termo bem conhecido no desenvolvimento web. Agora possvel escrever aplicaes desktop
como web2.0 usando AJAX. At o Struts 1.x, o desenvolvedor tinha que escrever e manter o cdigo em
javascript para adicionar o suporte AJAX.
Mas agora o Struts 2 lhe d o Ajax for a da caixa. Sem escrever javascript, sem debugar comparando
vrios browsers; apenas configure e vai.
Struts 2 vem com uma biblioteca de tags AJAX altamente configurveis quais podem ser usada diretamente
sem escrever cdigo JavaScrip. Struts 2 tambm suporta biblioteca Dojo. Agora muito fcil adicionar
caractersticas de AJAX habilitado como o Autocomplete a sua aplicao web.
Relacionado: Introduo ao DOJO Toolkit (em ingls)

Vamos ver a diferena bsica entre o framework Struts 1 e 2.

1. Diferente do
,o
no necessita de implementar a classe
.A
no
um
objeto
. Assim fazendo isso ficar fcil para teste unitrio do cdigo.
do
so
e deve ser
uma vez que s ter apenas uma instancia de uma
2.
. Objetos
do
so instanciados
classe para manipular todas as requisies para aquela
.
para cada requisio, ento no tem problemas de
3. As
do
tem dependncias da
desde que a HttpServletRequest e
HttpServletResponse passada ao mtodo execute quando uma
invocada. As
do
no so acopladas a um container. Mais frequentemente os contextos de
so representadas como
, permitindo
serem testadas em isolamento.
simples
usa um objeto
para capturar a entrada. Como as
, todos
devem
4.
no pode ser usada como
,
estender uma classe base. Uma vez que outro
desenvolvedores criam mais classes redundantes para capturar as entradas.
usa
, eliminando a necessidade por um segundo objeto de entrada.
como
podem ser tipos de objetos ricos quais podem ter suas prprias propriedades.
integra com
, assim utilizando o
. O tem
, mas
5.
pode utilizar
, mas o
relativamente uma coleo fraca e suporte de propriedades indexado.
) muito mais poderosa e
framework tambm suporta uma linguagem de expresso (
flexvel, chamada
(
).
usa o mecanismo padro
para fazer o
(amarrao) dos objeto dentro do contexto da
6.
usa um tecnologia
de modo que as
podem acessar valores
pgina para acesso.
ao tipo do objeto que ela est renderizando.
sem acoplar sua
7.
suporta separar
(ciclos de vida) para cada mdulo, mas todas as
no
suporta criar diferentes ciclos de vida em
modulo necessitam compartilhar o mesmo ciclo de vida.
via Interceptor
.
podem ser criadas e usada com diferentes
,
cada
conforme desejado.
A

Parte 2 - Tutorial: Criando uma aplicao Struts 2

no Eclipse
Sejam bem-vindos a
da srie de
onde vamos explorar o mundo do framework
. No artigo
anterior ns passamos pelo bsico do
, seu Diagrama de Arquitetura, ciclo de vida do processamento das
requisies e uma breve comparao do
e
. Se voc no passou no nosso artigo anterior, eu
altamente recomendo voc fazer isso antes de botar a mo na massa hoje.
p

Antes de ns comearmos com nosso primeiro exemplo Hello World no Struts 2, ns vamos precisar de
algumas ferramentas.

1.
2.
3.
4.

JDK 1.5 ou acima (download)

Tomcat 5.x ou acima ou qualquer outro container (Glassfish, JBoss, Websphere, Weblogic etc) (download)
Eclipse 3.2.x ou acima (download)
Arquivos JAR do Apache Struts2. Segue a lista dos arquivos JAR necessrios para essa aplicao.
o commons-logging-1.0.4.jar
o freemarker-2.3.8.jar
o ognl-2.6.11.jar
o struts2-core-2.1.6.jar
o xwork-2.1.2.jar

Observe que dependendo da verso utilizada do Struts2, o nmero da verso dos arquivos JAR
acima podem mudar.
N

Nosso objetivo criar uma aplicao bsica de Struts2 com uma pgina de Login. O usurio entrar com a
credencial de login(username e senha) e se for autenticado com sucesso ele ser redirecionado uma pgina
de Bem-Vindo na qual mostrar a mensagem Howdy, <username>!. Se o usurio no autenticar, ele
ser redirecionado de volta para pgina de login.

Vamos comear com a nosa primeira aplicao baseada em Struts2.

Abra o Eclipse e v em File -> New -> Project e selecione Dynamic Web Project na tela New Project.

Aps selecionar Dynamic Web Project, pressione Next.

Digite o nome do projeto. Por exemplo StrutsHelloWorld. Uma vez que fez isso, selecione o target runtime
environment (ex.: Apache Tomcat v6.0). Isso pra rodar o projeto dentro do ambiente do eclipse. Depois
disso clique em Finish.
Uma vez que o projeto est criado, voc pode ver essa estrutura no Project Explorer.

Agora copie todos os arquivos JAR requeridos no pasta WebContent -> WEB-INF -> lib. Crie essa pasta se
ela no existir.

Como discutido no artigo anterior, o ponto de entrada da aplicao Struts2 ser definir o Filter no web.xml.
Daqui ns definiremos uma entrada da classe org.apache.struts2.dispatcher.FilterDispatcher no web.xml.
Abra o arquivo web.xml que est abaixo da pasta WEB-INF e copie e cole o seguinte cdigo.
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<display-name>Struts2 Application</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>Login.jsp</welcome-file>
</welcome-file-list>

</web-app>

O cdigo acima no web.xml mapear o filtro do Struts2 com a url /*. O mapeamento padro de url para
aplicao struts2 ser /*.action. Tambm observe que ns temos que definir Login.jsp como arquivo de
boas-vindas.
Observao: O filtro FilterDispatcher est depreciado desde a verso 2.1.3 do Struts. Se voc est
utilizando a ltima verso do Struts2 ( > 2.1.3) utilize a classe StrutsPrepareAndExecuteFilter em vez
disso.
<filter>
<filter-name>struts2</filter-name>
<filterclass>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filterclass>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Precisaremos de uma classe Action que ir autenticar nosso usurio e manter o valor do username e da
senha. Para isso vamos criar um pacote net.viralpatel.struts2 na pasta source. Esse pacote conter o
arquivo action.

Crie uma classe chamada LoginAction no pacote net.viralpatel.struts2 com o seguinte conteudo.
package net.viralpatel.struts2;
public class LoginAction {
private String username;
private String password;
public String execute() {
if (this.username.equals("admin")
&& this.password.equals("admin123")) {
return "success";
} else {
return "error";
}
}

public String getUsername() {

return username;
}

public void setUsername(String username) {

this.username = username;
}

public String getPassword() {

return password;
}

public void setPassword(String password) {

this.password = password;
}
}

Observe que, a classe action acima contm dois campos, username e senha qual manter os valores do
formulrio e tambm contem o mtodo execute() que autenticar o usurio. Neste simples exemplo, ns
vamos checar se o username admin e a senha admin123.
Tambm observe que diferente da classe Action no Struts1, a classe Action do Struts2 uma simples classe
POJO com os atributos necessrios e mtodo.
O mtodo execute() retorna um valor String qual ir determinar a pgina de resultado. Tambm, no Struts2
o nome do mtodo no fixo. Neste exemplo ns devemos definir o mtodo execute(). Voc pode querer
definir um mtodo authenticate() em vez disso.
O

ResourceBundle uma entidade Java muito til que ajuda a colocar o contedo esttico fora do arquivo
fonte. A maioria das aplicaes definem um arquivo resource bundle como ApplicationResources.properties
o qual conter mensagens estticas como Username e Senha e inclui isso com a aplicao.
ResourceBundle se torna til quando ns queremos adicionar suporte a internacionalizao(I18N) a uma
aplicao.
Ns definiremos um arquivo ApplicationResources.properties para nossa aplicao. Esse arquivo de
propriedade deve estar presente na pasta WEB-INF/classes quando a fonte for compilada. Portanto criaremos
uma pasta source chamada resources e colocar esse arquivo ApplicationResources.properties dentro dela.

Para criar uma pasta source, clique com o boto direito no seu projeto no Project Explorer e selecione New > Source Folder.

Especifique o nome da pasta como resources e clique em Finish.

Crie um arquivo ApplicationResources.properties embaixo da pasta resources.

Copie o sequinte contedo dentro do ApplicationResources.properties.

label.username= Username
label.password= Password
label.login= Login

Ns vamos criar dois arquivos JSP para renderizar a sada ao usurio. Login.jsp ser o ponto de partida da
nossa aplicao, no qual conter um simples formulrio de login com username e senha. Em uma
autenticao bem sucedida, o usurio ser redirecionado Welcome.jsp que ir mostrar uma simples
mensagem de boas vindas.
Crie dois arquivos JSP Login.jsp e Welcome.jsp na pasta WebContent do seu projeto. Copie o seguinte
contedo dentro deles.
L

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Struts 2 - Login Application | ViralPatel.net</title>
</head>

<body>

<h2>Struts 2 - Login Application</h2>

<s:actionerror />
<s:form action="login.action" method="post">
<s:textfield name="username" key="label.username" size="20" />
<s:password name="password" key="label.password" size="20" />
<s:submit method="execute" key="label.login" align="center" />
</s:form>
</body>
</html>
W

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Welcome</title>
</head>

<body>
<h2>Howdy, <s:property value="username" />...!</h2>
</body>
</html>

Observe que ns usamos a tag <s:> do Struts 2 para renderizar as caixas de texto e labels. Struts2 vem com
uma ponderosa biblioteca de tags embutida para renderizar elementos UI com mais eficincia.

O Struts2 l a configurao e a definio de classe de um arquivo XML chamado struts.xml. Esse arquivo
carregado do classpath do projeto. Ns definiremos o arquivo struts.xml na pasta resources. Crie o arquivo
struts.xml na pasta resources.

Copie o seguinte contedo dentro do struts.xml.

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
<constant name="struts.enable.DynamicMethodInvocation"
value="false" />
<constant name="struts.devMode" value="false" />
<constant name="struts.custom.i18n.resources"
value="ApplicationResources" />

<package name="default" extends="struts-default" namespace="/">

<action name="login"
class="net.viralpatel.struts2.LoginAction">
<result name="success">Welcome.jsp</result>
<result name="error">Login.jsp</result>
</action>
</package>
</struts>

Observe que no arquivo de configurao acima, ns temos definido a action Login da nossa aplicao. Dois
result paths (caminhos de resultado) esto mapeados com LoginAction dependendo do resultado do mtodo
execute(. Se o mtodo execute() retornar sucesso, o usurio ser redirecionado para Welcome.jsp se
no para Login.jsp.
Tambm observe que uma Constant especificada com o nome struts.custom.i18n.resources. Essa
constante especifica o arquivo resource bundle que ns criamos nos passos acima. Ns apenas precisamos
especificar o nome do arquivo resource bundle sem a extenso (ApplicationResources sem o .properties).
Nosso LoginAction contm o mtodo execute() o qual o mtodo padro sendo chamado pelo Struts2. Se o
nome do mtodo diferente, ex.: authenticate(); ento devemos especificar o nome do mtodo na tag
<action>.
<action name="login" method="authenticate"
class="net.viralpatel.struts2.LoginAction">

A aplicao est quase pronta. Voc talvez queira rodar a aplicao agora e ver o resultado voc mesmo. Eu
presumo que voc j tenha configurado o Tomcat no eclipse. Tudo que voc precisa fazer:
Abrir a view de Server em Windows -> Show View -> Server. Boto direito nesta view e selecionar New ->
Server e adicionar os detalhes do seu servidor.
Para rodar o projeto, boto direito no nome do projeto no Project Explorer e selecione Run as -> Run on
Server (Atalho: Alt+Shift+X, R)
Mas ai tem um pequeno problema. Nossa aplicao roda perfeitamente bem at este ponto. Mas ento o
usurio entra com as credenciais erradas, ela ser redirecionada para pgina de Login. Mas nenhuma
mensagem de erro mostrada. O usurio no sabe oque aconteceu. Uma boa aplicao sempre mostrar
mensagens de erro apropriadas ao usurio. Ento ns devemos mostrar uma mensagem de erro Invalid
Username/Password. Please try again quando a autenticao do usurio falhar.
T

Para adicionar essa funcionalidade, primeiro ns vamos adicionar a mensagem de erro no nosso arquivo
ResourceBundle. Abra o ApplicationResources.properties e adicione uma entrada para error.login. O
ApplicationResources.properties final parecer como:
label.username= Username
label.password= Password
label.login= Login
error.login= Invalid Username/Password. Please try again.

Ns tambm precisamos adicionar lgica no LoginAction para adicionar a mensagem de erro se o usurio
no autenticar. Mas ai ns temos um problema. Nossa mensagem de erro est especificada no arquivo
ApplicationResources.properties. Ns precisamos especificar a chave error.login no LoginAction e a
mensagem dever aparecer na pgina JSP.
Para isso ns precisamos implementar a interface com.opensymphony.xwork2.TextProvider que fornece
o mtodo getText(). Esse mtodo retorna um valor String do arquivo resource bundle. Ns precisamos
apenas passar o valor chave como argumento para o mtodo getText(). A interface TextProvider define
vrios mtodos que ns precisamos implementar a fim de conseguir segurar o mtodo getText(). Mas ns
no queremos estragar o nosso cdigo adicionando todos esses mtodos que no temos a inteno de usar.
Tem um bom jeito de lidar com este problema.
Struts2 vem com uma classe muito til com.opensymphony.xwork2.ActionSupport. Ns precisamos
estender nossa classe LoginAction com esta classe e diretamente usar mtodos como o getText(),
addActionErrors() e etc. Portanto ns iremos estender a classe LoginAction com a classe ActionSupport e
adicionar a lgica para reportar o erro dentro dela. O cdigo final do LoginAction deve se parecer com:
package net.viralpatel.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {

private String username;

private String password;

public String execute() {

if (this.username.equals("admin")
&& this.password.equals("admin123")) {
return "success";
} else {
addActionError(getText("error.login"));
return "error";
}
}

public String getUsername() {

return username;
}

public void setUsername(String username) {

this.username = username;
}

public String getPassword() {

return password;
}

public void setPassword(String password) {

this.password = password;
}
}

E isso. Nossa primeira aplicao Hello World em Struts2 est pronta.

Execute a aplicao no eclipse e rode-o no seu navegador favorito.

Pgina de Login

Pgina de boas vindas

Pgina de Login com erro

Cdigo fonte sem os arquivos JAR (9 KB)

Cdigo fonte com os arquivos JAR (3 MB)
F

Parte 3 Tutorial do Framework de validao do

Struts2 com Exemplo
Seja bem vindo a parte 3 de uma srie de 7 partes do tutorial aonde vamos passar por diferentes aspectos
prticos do framework Struts2. Na ltima parte ns criamos uma Aplicao bsica de Struts2 do zero. Eu
recomendo fortemente que voc passe pelos artigos anteriores no caso de voc ser novo no Struts2.
Nesse artigo vamos aprender como alavancar o framework de validao do Struts2 em uma aplicao. Para
isso utilizaremos a aplicao StrutsHelloWorld a qual ns criamos no artigo anterior como base e
comearemos adicionando a lgica de validao a ele.
I

A action do Struts2 depende de um framework de validao fornecido pela XWork para permitir a aplicao
de regras de validao de entrada para nossa Action antes delas serem executadas. O framework de
validao do Struts2 nos permite separar a lgica de validao do real cdigo Java/JSP, onde isso pode ser
revisado e facilmente modificado depois.
O framework de validao do Struts2 alivia muita das dores de cabea associadas com manipulao de
validao de dado, permitindo voc focar no cdigo de validao e no no mecanismo de captura de dados e
reexibio de dados incompletos ou invlidos.
O framework de validao vem com um conjunto de retinas teis para manipular o formulrio de validao
automaticamente e isso pode tratar o formulrio de validao de ambos os lados, servidor (Server Side) ou
cliente (Client Side). Se determinada validao no est presente, voc pode criar sua prpria lgica de
validao implementando a interface com.opensymphony.xwork2.Validator e plug-la dentro do
framework de validao como um componente reutilizvel.
O validador usa arquivos de configurao XML para determinar quais rotinas de validao devem ser
instaladas e quais delas devem ser aplicadas para uma determinada aplicao.O arquivo validators.xml
contm todas as declaraes dos validadores comuns. Se o arquivo validators.xml no estiver presente no
classpath, um arquivo de validao padro carregado do path
com/opensymphony/xwork2/validator/validators/default.xml.
O primeiro arquivo de configurao, declara as rotinas de validao que devem ser plugadas dentro do
framework e fornece nomes lgicos para cada uma das validaes. O arquivo validator-rules.xml tambm
define o cdigo JavaScript do lado cliente para cada rotina de validao. O validador pode ser configurado
para enviar esse cdigo JavaScript para o navegador ento essas validaes so realizadas tanto do lado
cliente quanto do lado servidor.
E

Temos 2 tipos de validadores na Validao do Struts2.

1. Field Validators (
2. Non-field validators (
V

Field validators, como o nome indica, atua em um nico campo acessvel atravs de uma action. Um
validador, em contrapartida, mais genrico e pode fazer validaes no contexto inteiro da action,
invocando mais de um campo (ou at mesmo nenhum campo) na regra de validao. A maioria das
validaes podem ser definidas em forma de campo. Isso deve ter preferncia sobre validao non-field
sempre que possvel, como mensagens de validao de campo so vinculados ao campo relacionado e ser
apresentado prximo ao elemento de entrada correspondente na view respectiva.

<validators>
<field name="bar">
<field-validator type="required">
<message>You must enter a value for bar.</message>
</field-validator>
</field>
</validators>

Non-field validators apenas adiciona mensagens de nvel de action. Validaes non-field fornecida pela
XWork ExpressionValidator (Validador de Expresso).
<validators>
<validator type="expression">
<param name="expression">foo lt bar</param>
<message>Foo must be greater than Bar.</message>
</validator>
</validators>

Vamos adicionar a lgica de validao na aplicao StrutsHelloWorld que ns criamos no artigo anterior.
Para esse tutorial, vamos criar uma classe Action chamada CustomerAction a qual conter poucos campos.
Crie um arquivo CustomerAction.java no pacote net.viralpatel.struts2.

Copie o seguinte contedo dentro dele.

CustomerAction.java
package net.viralpatel.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class CustomerAction extends ActionSupport{

private String name;
private Integer age;
private String email;

private String telephone;

public String addCustomer() {

return SUCCESS;
}

public String getName() {

return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
}

Observe que a classe CustomerAction tem os campos name, email, telephone e age. Tambm tem um
mtodo chamado addCustomer() o qual no tem nenhuma lgica, ele apenas retorna SUCCESS.

Agora ns vamos adicionar uma entrada para essa classe action no arquivo struts.xml. Abra o arquivo
struts.xml o qual estar presente abaixo da pasta resources. E adicione o seguinte contedo entre as tags
<package></package>.
<action name="customer"
class="net.viralpatel.struts2.CustomerAction">
<result name="success">SuccessCustomer.jsp</result>
<result name="input">Customer.jsp</result>
</action>

Observe que ns estamos mapeando a classe CustomerAction com o nome customer. Tambm em sucesso o
usurio ser redirecionado a pgina SuccessCustomer.jsp. Repare que tem outra tag de resultado com nome
input. Sempre que a lgica de validao encontra algum erro de validao, redireciona o usurio de volta a
pgina especificada como input. Assim no nosso exemplo, o usurio ser redirecionado de volta para
Customer.jsp no caso de quaisquer erros.
Crie duas novas JSPs Customer.jsp (qual conter o formulrio do Customer) e SuccessCustomer.jsp
(qual ser mostrada em sucesso).

Customer.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Customer Form - Struts2 Demo | ViralPatel.net</title>
</head>

<body>
<h2>Customer Form</h2>

<s:form action="customer.action" method="post">

<s:textfield name="name" key="name" size="20" />
<s:textfield name="age" key="age" size="20" />
<s:textfield name="email" key="email" size="20" />
<s:textfield name="telephone" key="telephone" size="20" />

<s:submit method="addCustomer" key="label.add.customer" align="center" />

</s:form>
</body>
</html>

SuccessCustomer.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Customer Page - Struts2 Demo | ViralPatel.net</title>
</head>

<body>
<h2>Customer Added Successfully.</h2>
</body>
</html>

Ns criamos o arquivo Customer.jsp qual ir exibir o formulrio Customer. Mas ns no temos link para
esta pgina na nossa aplicao web. Ento ns criaremos um link para Customer.jsp da pgina Welcome.jsp.
Abra a pgina Welcome.jsp e adicione o seguinte cdigo de link dentro dela.
<s:a href="Customer.jsp">Add Customer</s:a>

Agora abra o arquivo ApplicationResources.properties da pasta resources e adicione as seguintes

chaves/valores dentro dela.
name= Name
age= Age
email= Email
telephone= Telephone
label.add.customer=Add Customer
errors.invalid=${getText(fieldName)} is invalid.
errors.required=${getText(fieldName)} is required.
errors.number=${getText(fieldName)} must be a number.
errors.range=${getText(fieldName)} is not in the range ${min} and ${max}.

Execute o cdigo no Eclipse e veja a saida. Voc ver a pgina de login. Entre com username=admin e a
senha=admin123 e faa o login. Na pgina de boas vindas voc ver um link para pgina Add Customer.
Clique naquele link e voc ver a pgina Customer..

Agora ns terminamos o bsico do formulrio customer no qual ns vamos adicionar a lgica de validao.
Seguem as regras de validaes:
1.
2.
3.
4.

Campo Name obrigatrio.

Campo Age obrigatrio. Deve ser um nmero entre 1 e 100.
Campo Email obrigatrio. Deve ser um endereo de email vlido.
Campo Telephone obrigatrio.

A fim de definir a lgica de validao para um formulrio em particular, primeiro ns devemos criar um
arquivo XML no qual manter esse dado. O Struts2 define uma conveno de nomenclatura especfica na
definio dos arquivos XML de validao. O formato <NomeDaClasseAction>-validation.xml. Ento
para nossa aplicao vamos criar um arquivo CustomerAction-validation.xml. Observe que este arquivo
deve estar presente no mesmo pacote da classe action.
Crie o arquivo CustomerAction-validation.xml no pacote net.viralpatel.struts2. E copie o seguinte contedo
dentro dele.

CustomerAction-validation.xml
<!DOCTYPE validators PUBLIC "-//Apache Struts//XWork Validator 1.0.3//EN"
"http://struts.apache.org/dtds/xwork-validator-1.0.3.dtd">
<validators>
<field name="name">
<field-validator type="requiredstring">

<param name="trim">true</param>
<message key="errors.required" />
</field-validator>
</field>
<field name="age">
<field-validator type="required">
<message key="errors.required" />
</field-validator>
<field-validator type="int">
<param name="min">1</param>
<param name="max">100</param>
<message key="errors.range"/>
</field-validator>
</field>
<field name="email">
<field-validator type="requiredstring">
<message key="errors.required" />
</field-validator>
<field-validator type="email">
<message key="errors.invalid" />
</field-validator>
</field>
<field name="telephone">
<field-validator type="requiredstring">
<message key="errors.required" />
</field-validator>
</field>
</validators>

E isso. Ns apenas adicionamos a lgica de validao ao nosso exemplo. Veja que os arquivos XML de
validao contm diferentes field-validators.
V

muito fcil adicionar a validao do lado cliente ou validao JavaScript a qualquer formulrio em
Struts2. Tudo o que voc precisa fazer adicionar validate=true na tag form no seu arquivo JSP. Por

exemplo abra o Customer.jsp e adicione validate=true na tag form. O Struts2 automaticamente gerar o
cdigo JavaScript para validao do lado cliente do formulrio.
<s:form action="customer.action" method="post" validate="true">
...
</s:form>

Execute a aplicao e teste o formulrio Customer com diferentes valores.

Pgina Customer

Pgina Customer com erros

Pgina Customer com sucesso

Struts2_Validation_example.zip (3.6 MB)

Fonte: viralpatel.net - Viral Patel

Parte 4 - Tutorial do Plugin Struts 2 Tiles com

exemplo no Eclipse
Bem vindos parte 4 de uma srie de 7 partes, onde ns passaremos por diferentes aspectos do
Framework Struts2 com alguns exemplos teis. Na parte anterior ns passamos por Framework de
validao do Struts2. Ns vimos como fcil integrar validao na sua aplicao Struts2.
Nesta parte vamos discutir sobre o Framework Tile e a sua integrao com Struts2. Ns vamos adicionar o
suporte Tiles a nossa aplicao de Struts HelloWorld que ns criamos anteriormente. Eu recomendo voc
passar pelos artigos anteriores e baixar o cdigo fonte da nossa aplicao de exemplo.
I

Atualmente, um website geralmente dividido em pedaos de templates que so renderizados entre

diferentes pginas web. Por exemplo, um site contendo um header (cabealho), footer (rodap), menu e etc.
Estes itens permanecem os mesmos por todo o site e dando um visual padro. Isso muito difcil de
codificar em cada pgina web e se depois uma modificao necessria, ento todas as pginas precisam ser
modificadas. Por isso ns usamos o mecanismo de Templatization. Ns criamos uma pgina padro de
Header, Footer, Menu e etc., e a inclumos em cada pgina.
O plugin Tile premite ambos templating e componentizao. De fato, ambos mecanismos so similates:
voc define partes da pgina (uma Tile/Telha) que voc junta para construir outra parte ou uma pgina
inteira. Uma parte pode receber parmetros, permitindo um contedo dinmico, e pode ser visto como um
mtodo na linguagem Java. Tiles um sistema de templating usado para manter um visual consistente
atravs de todas as pginas web de uma aplicao web. Isso aumenta a reusabilidade do template e reduz a
duplicao de cdigo.
Um layout comum de website definido em um arquivo de configurao central e esse layout pode ser
estendido atravs de todas as pginas web da aplicao.

Nossa meta adicionar um Header, Footer e Menu ao nossa aplicao StrutsHelloWorld.

Abaixo segue o layout da mesma.

A fim de adicionar o suporte Tiles a nossa aplicao Struts2, ns precisaremos de alguns arquivos JARs.
Abaixo segue a lista de JARs do nosso exemplo. Adicione estes JARs na pasta WEB-INF/lib.

Para configurar o Tiles, uma entrada de listener tem que ser criada no web.xml. Abra o web.xml na pasta
WEB-INF e adicione o seguinte cdigo.
<listener>
<listener-class>
org.apache.struts2.tiles.StrutsTilesListener
</listener-class>
</listener>

<context-param>
<param-name>tilesDefinitions</param-name>
<param-value>/WEB-INF/tiles.xml</param-value>
</context-param>

O cdigo acima configure o listener do Tiles no web.xml. Um arquivo de configurao de entrada /WEBINF/tiles.xml passado como argumento. Este arquivo contm a definio do Tiles para sua aplicao
web.
Crie um arquivo tiles.xml na pasta WEB-INF e copie o seguinte cdigo dentro dele.

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE tiles-definitions PUBLIC

"-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
"http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
<tiles-definitions>
<definition name="baseLayout" template="/BaseLayout.jsp">
<put-attribute name="title" value="" />
<put-attribute name="header" value="/Header.jsp" />
<put-attribute name="menu" value="/Menu.jsp" />
<put-attribute name="body" value="" />
<put-attribute name="footer" value="/Footer.jsp" />
</definition>
<definition name="/welcome.tiles" extends="baseLayout">
<put-attribute name="title" value="Welcome" />
<put-attribute name="body" value="/Welcome.jsp" />
</definition>
<definition name="/customer.tiles" extends="baseLayout">
<put-attribute name="title" value="Customer Form" />
<put-attribute name="body" value="/Customer.jsp" />
</definition>

<definition name="/customer.success.tiles" extends="baseLayout">

<put-attribute name="title" value="Customer Added" />
<put-attribute name="body" value="/SuccessCustomer.jsp" />
</definition>
</tiles-definitions>

Aqui no tile.xml ns temos que definir um template baseLayout. Este layout contm atributos como
Header, Title, Body, Menu e Footer. O layout depois estendido, e novas definies para as pginas
Welcome e Customer so definidas. Ns temos que substituir o layout padro e mudar o contedo de Body e
Title.
C

Ns definiremos o template para nossa aplicao web em uma arquivo JSP chamado BaseLayout.jsp. Este
template ir conter diferentes segmentos da pgina (Header, Footer, Menu etc). Crie 4 novos arquivos JSP
BaseLayout.jsp, Header.jsp, Menu.jsp and Footer.jsp e copie o seguinte contedo em cada um deles.
BaseLayout.jsp
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title><tiles:insertAttribute name="title" ignore="true" /></title>
</head>
<body>
<table border="1" cellpadding="2" cellspacing="2" align="center">
<tr>
<td height="30" colspan="2"><tiles:insertAttribute name="header" />

</td>
</tr>
<tr>
<td height="250"><tiles:insertAttribute name="menu" /></td>
<td width="350"><tiles:insertAttribute name="body" /></td>
</tr>
<tr>
<td height="30" colspan="2"><tiles:insertAttribute name="footer" />
</td>
</tr>
</table>
</body>
</html>

Header.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<h2>Struts2 Example - ViralPatel.net</h2>

Menu.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<s:a href="customer-form">Customer</s:a>

Footer.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
Copyright &copy; ViralPatel.net Traduo SpigandoEAprendendo.wordpress.com

No struts.xml ns definimos a tag de resultado (result) que mapeia uma ao especfica com uma pgina
JSP. Agora ns modificaremos isso e mapearemos o resultado com Tiles. Abaixo segue o contedo do
arquivo struts.xml.
<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
<constant name="struts.enable.DynamicMethodInvocation"
value="false" />
<constant name="struts.devMode" value="false" />
<constant name="struts.custom.i18n.resources"
value="ApplicationResources" />

<package name="default" extends="struts-default" namespace="/">

<result-types>
<result-type name="tiles"
class="org.apache.struts2.views.tiles.TilesResult" />
</result-types>
<action name="login"
class="net.viralpatel.struts2.LoginAction">
<result name="success" type="tiles">/welcome.tiles</result>
<result name="error">Login.jsp</result>
</action>
<action name="customer"
class="net.viralpatel.struts2.CustomerAction">
<result name="success" type="tiles">/customer.success.tiles</result>
<result name="input" type="tiles">/customer.tiles</result>
</action>
<action name="customer-form">
<result name="success" type="tiles">/customer.tiles</result>
</action>
</package>
</struts>

O struts.xml agora define um novo tipo de Resultado pelo Tiles. Esse tipo de resultado usado na tag
<result> para diferentes aes. Tambm observe que ns vamos definir uma nova ao customer-form.

Esta apenas uma declarao vazia para redirecionar o Usuario para pgina do formulrio Customer quando
ela clica no link Customer no menu.

Compile e execute a aplicao no Eclipse e veja que o header, menu e o footer esto apropriadamente
aplicados.
Pgina de Boas Vindas com Tiles

Pgina Customer com Tiles

Pgina de Sucesso Customer com Tiles

Clique aqui para fazer o download do cdigo fonte (sem os JARs) (11KB)
F

Parte 5 Tutorial de Interceptadores

(Interceptors) do Struts2 com Exemplo
Sejam vem vindos a parte 5 de uma srie de 7 partes aonde ns vamos examinar aspectos diferentes do
framework Struts2. No artigo anterior ns vimos como integrar o framework Tile com o Struts2.
Hoje vamos explorer o mundo dos Interceptadores(Interceptors) no Struts2. Ns vamos ver o que os
interceptadores so e como configura-los em uma aplicao web baseada em Struts2.
I

O Struts2 fornece um mecanismo poderoso para controlar uma requisio usando Interceptadores.
Interceptadores so responsveis pela maior parte do processamento de requisies. Eles so invocados pelo
controller (controlador) antes e depois de invocar uma action, assim eles ficam entre o controller e a action.
Interceptadores executam tarefas como Logging, Validation, File Upload, Double-submit guard e etc.

O ciclo de vida de processamento do framework Struts2 bastante discutido na parte 1 do tutorial.

1. A requisio gerada pelo usurio e enviada ao
container.
container invoca o filtro
que por sua vez determina a ao apropriada.
2.
so aplicados ante de chamar a
. Interceptors executam tarefas como
3. Um por um dos
,
,
,
e etc.
executada e o
gerado pela
.
4.
5. A sada da
renderizada na view (
, etc) e o resultado retornado ao usurio.
S

Portanto os interceptadores do Struts2 removem funes cross cutting como logging de componentes action e

cria uma separao mais limpa do MVC.

O Struts2 vem com uma lista padro de interceptadores j configurada na aplicao, no arquivo strutsdefault.xml. Ns podemos criar nossas prprios interceptadores e pluga-los dentro de uma aplicao web
baseada em Struts2.
O framework cria um objeto de ActionInvocation que encapsula a action e todos os interceptadores
configurados para aquela action. Cada interceptador chamado antes da action ser chamada. Uma vez que a
action chamada e o resultado gerado, cada interceptador chamado de novo na ordem contrria para
executar o trabalho de ps-processamento. Interceptadores podem alterar o workflow (fluxo de trabalho) da
action. Isso talvez impessa a execuo da action.
N

Nossa meta sera criar um interceptador customer MyLoggingInterceptor, o qual ir logar a requisio antes
de qualquer action ser chamada. Ele tambm ir imprimir o nome da classe Action e o tempo de execuo
em milisegundos.
C

Crie uma classe java MyLoggingInterceptor no pacote net.viralpatel.struts2.interceptors e copie

o seguinte contedo dentro dela.

package net.viralpatel.struts2.interceptor;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.Interceptor;

public class MyLoggingInterceptor implements Interceptor{

private static final long serialVersionUID = 1L;

public String intercept(ActionInvocation invocation) throws Exception {

String className = invocation.getAction().getClass().getName();

long startTime = System.currentTimeMillis();
System.out.println("Before calling action: " + className);

String result = invocation.invoke();

long endTime = System.currentTimeMillis();

System.out.println("After calling action: " + className
+ " Time taken: " + (endTime - startTime) + " ms");

return result;
}

public void destroy() {

System.out.println("Destroying MyLoggingInterceptor...");
}
public void init() {
System.out.println("Initializing MyLoggingInterceptor...");
}
}

Uma vez que ns criamos uma classe interceptadora, tudo o que precisamos fazer configurar ela no
arquivo struts.xml e usa-la com as actions.
Para configurar o interceptador criado h pouco, adicione o seguinte cdigo dentro do struts.xml

<interceptors>
<interceptor name="mylogging"
class="net.viralpatel.struts2.interceptor.MyLoggingInterceptor">
</interceptor>
<interceptor-stack name="loggingStack">
<interceptor-ref name="mylogging" />
<interceptor-ref name="defaultStack" />
</interceptor-stack>
</interceptors>

Esse cdigo deve ser adicionado depois da tag <result-types > no <package ></package>. Aqui ns
configuramos um novo interceptador mylogging com a tag <interceptor >. Tambm veja que ns definimos
um interceptor-stack com o nome de loggingStack. Isso para ter certeza de que o Struts2 chamar todos
os interceptadores padres assim como chamar o nosso interceptador customizado. Isso muito importante
como por exemplo a lgica de validao no ser chamada na nossa aplicao Struts2 se ns ignorarmos o
stack padro (defaultStack) dos interceptadores.
Ns podemos fazer o novo loggingStack como interceptador padro ou podemos configurar ele em cada
nvel de action. A fim de faze-lo um stack padro, ns devemos adicionar o seguinte no struts.xml
<default-interceptor-ref name="loggingStack"></default-interceptor-ref>

Uma vez que ns adicionamos o cdigo acima no Struts.xml, o logginStack ser aplicado todas as action
daquele pacote.
Tambm ns talvez quisssemos aplicar o interceptador customizado para apenas determinadas actions. Para
fazer isso, ns precisamos adicionar a tag interceptor-ref na action.
<action name="login"
class="net.viralpatel.struts2.LoginAction">
<interceptor-ref name="loggingStack"></interceptor-ref>
<result name="success" type="tiles">/welcome.tiles</result>
<result name="error">Login.jsp</result>
</action>

Se ns executarmos nossa aplicao StrutsHelloWorld no ecplipse e olharmos os logs do console, ns vamos

encontrar as declaraes de log que ns imprimimos no nosso interceptador.
Initializing MyLoggingInterceptor...
..

..
..
Before calling action: net.viralpatel.struts2.LoginAction
..
..
After calling action: net.viralpatel.struts2.LoginAction Time taken: 313 ms
..
..
..
Destroying MyLoggingInterceptor...

Clique aqui para fazer o download do cdigo fonte sem os JARs (17KB)
F

Parte 6 Tutorial de Upload e Gravao de

Arquivos do Struts 2 com Exemplo
Bem vindos a parte 6 de uma srie de 7 partes do framework Struts2. Na parte anterior ns passamos pelo
bsico dos Interceptadores do Struts2. Tambm criamos um interceptador customizado e o integramos a
aplicao Struts2.
bastante recomendvel passar pelos artigos anteriores no caso de voc ser novo no framework Struts2.
Hoje vamos ver como fazer um Upload de Arquivos no Struts2. Ns vamos utilizar o interceptador
FileUploadInterceptor que vem embutido no Struts2, no nosso exemplo para fazer o upload do arquivo. O
interceptador de upload de arquivos do Struts2 baseado no MultiPartRequestWrapper, o qual
automaticamente aplicado a requisio se ela contm um elemento de arquivo.
A

Antes de comear, voc precisa ter certeza que o arquivo commons-io.jar est presente no classpath. Segue
a lista de arquivos JAR necessrios.

A fim de adicionar a funcionalidade de upload de arquivos, ns vamos adicionar uma classe action
FileUploadAction ao nosso projeto. Crie o arquivo FileUploadAction.java no pacote
net.viralpatel.struts2

FileUploadAction.java
package net.viralpatel.struts2;

import java.io.File;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.io.FileUtils;
import org.apache.struts2.interceptor.ServletRequestAware;
import com.opensymphony.xwork2.ActionSupport;

public class FileUploadAction extends ActionSupport implements

ServletRequestAware {
private File userImage;
private String userImageContentType;
private String userImageFileName;

private HttpServletRequest servletRequest;

public String execute() {

try {
String filePath =
servletRequest.getSession().getServletContext().getRealPath(/);
System.out.println("Server path:" + filePath);
File fileToCreate = new File(filePath, this.userImageFileName);

FileUtils.copyFile(this.userImage, fileToCreate);
} catch (Exception e) {
e.printStackTrace();
addActionError(e.getMessage());

return INPUT;
}
return SUCCESS;
}

public File getUserImage() {

return userImage;
}

public void setUserImage(File userImage) {

this.userImage = userImage;
}

public String getUserImageContentType() {

return userImageContentType;
}

public void setUserImageContentType(String userImageContentType) {

this.userImageContentType = userImageContentType;
}

public String getUserImageFileName() {

return userImageFileName;
}

public void setUserImageFileName(String userImageFileName) {

this.userImageFileName = userImageFileName;
}

@Override
public void setServletRequest(HttpServletRequest servletRequest) {

this.servletRequest = servletRequest;

}
}

No arquivo da classe acima, ns declaramos alguns atributos:

private File userImage; -> Isso ir armazenar o arquivo carregado
private String userImageContentType; -> Essa string conter o Content Type do arquivo carregado.
private String userImageFileName; -> Essa string ir conter o nome do arquivo carregado.

Os campos userImageContentType e userImageFileName so opcionais. Se o mtodo setter desse campos

for fornecido, o Struts2 ir setar o dado. Isso apenas para pegar alguma informao extra do arquivo
carregado. Segue tambm o padro de nomeao, se voc fornecer o tipo do contedo e o nome do arquivo.
O nome deve ser ContentType e FileName. Por exemplo, se o atributo arquivo (File) na action for private
File uploadedFile, o tipo do contedo ser uploadedFileContentType e o nome do arquivo
uploadedFileFileName.
Observe tambm na classe action acima, ns implementamos a interface
org.apache.struts2.interceptor.ServletRequestAware. Isto para pegar o objeto servletRequest. Ns
estamos usando esse path para salvar o arquivo carregado no mtodo execute(). Ns usamos o mtodo
FileUtil.copyFile() do pacote commons-io para copiar o arquivo carregado na pasta root. Esse arquivo
ser recuperado na pgina JSP e exibido ao usurio.
O

Crie dois arquivos JSP na pasta WebContent. UserImage.jsp ir exibir um formulrio para o usurio carregar
a imagem. Ao submeter, o arquivo ser carregado e salvo no servidor. O usurio ser enviado ao arquivo
SuccessUserImage.jsp aonde ter os detalhes do arquivo sero exibidos. Copie o seguinte cdigo dentro
dele.

UserImage.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Upload User Image</title>
</head>

<body>
<h2>Struts2 File Upload & Save Example</h2>
<s:actionerror />

<s:form action="userImage" method="post" enctype="multipart/form-data">

<s:file name="userImage" label="User Image" />
<s:submit value="Upload" align="center" />
</s:form>
</body>
</html>

SuccessUserImage.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Success: Upload User Image</title>
</head>
<body>
<h2>Struts2 File Upload Example</h2>
User Image: <s:property value="userImage"/>
<br/>
Content Type: <s:property value="userImageContentType"/>
<br/>
File Name: <s:property value="userImageFileName"/>
<br/>
Uploaded Image:
<br/>
<img src="<s:property value="userImageFileName"/>"/>
</body>
</html>

Adicione a seguinte entrada da classe FileUploadAction ao arquivo struts.xml.

<action name="userImage"
class="net.viralpatel.struts2.FileUploadAction">
<interceptor-ref name="fileUpload">

<param name="maximumSize">2097152</param>
<param name="allowedTypes">
image/png,image/gif,image/jpeg,image/pjpeg
</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"></interceptor-ref>
<result name="success">SuccessUserImage.jsp</result>
<result name="input">UserImage.jsp</result>
</action>

Observe que na entrada acima ns especificamos dois parmetros ao interceptador fileUpload,

maximumSize e allowedTypes. Estes so parmetros opcionais que ns podemos especificar ao
interceptador. O parmetro maximumSize setar o tamanho mximo do arquivo que poder ser carregado.
Por padro 2MB. E o parmetro allowedTypes especifica os tipos de contedos permitidos do arquivo que
ser carrregado. Aqui ns o especificamos para ser um arquivo de imagem
(image/png,image/gif,image/jpeg,image/pjpeg).
O interceptador de carga de arquivo tambm faz a validao e adiciona erros, essas mensagens de erros so
armazenadas dentro do arquivo struts-messsages.properties. Os valores das mensagens podem ser
sobrescritos fornecendo texto/valor para as seguintes chaves:

erro quando a carga do arquivo falha

erro ocorrido quando o tamanho do arquivo grande
quando o tipo do contedo no permitido
e

Compile e execute o projeto no eclipse e v ao link http://localhost:8080/StrutsHelloWorld/UserImage.jsp

Tela de carga de imagem

Tela de carga de imagem no caso de erro

Tela de carga de imagem em sucesso

Clique aqui para fazer o download do cdigo fonte sem os JARs (20KB)
F

Parte 7 (Final) Tutorial de Ajax no Struts 2 com

Exemplo
Bem vindo a ultima parte de uma srie de 7 artigos de tutoriais do Framework Struts2, no artigo anterior ns vimos
como implementar a funcionalidade de carga de arquivo (File Upload) no Struts2. Neste artigo ns vamos ver como
ns podemos implementar o suporte Ajax em uma aplicao web usando o framework struts2.
S

O Struts 2 fornece suporte embutido a Ajax usando a biblioteca Dojo Toolkit. Se voc novo em Dojo,
talvez voc queira passar pela Introduo ao DOJO Toolkit (Em Ingls).
O Struts 2 vem com um poderoso conjunto de APIs de Dojo AJAX que voc pode usar para adicionar
suporte Ajax. A fim de adicionar suporte Ajax, voc precisa adicionar o seguinte arquivo JAR no seu
classpath:
struts2-dojo-plugin.jar
Uma vez que ns adicionamos esse arquivo JAR, ns precisamos adicionar o seguinte fragmento de cdigo
em qualquer arquivo JSP que ns precisamos adicionar o suporte Ajax.
<%@ taglib prefix="sx" uri="/struts-dojo-tags"%>

Primeiro defina a taglib sx que ns usaremos para adicionar as tags disponveis de AJAX.
<sx:head/>

Adicione essa tag head no seu JSP entre as tags <head> </head>. Essa tag sx:head incluir os arquivos
javascript e css necessrios pra implementar o Ajax.
E

Vamos adicionar um simples suporte AJAX a nossa aplicao web StrutsHelloWorld. Ns usaremos o
cdigo base que ns usamos nos artigos anteriores e adicionar o Ajax no topo dele.
Ns criaremos um drop down (combobox) qual ir autocompletar e sugerir a entrada. Para isso ns iremos
adicionar o suporte Dojo a nossa app web.
P

Como discutido anteriormente ns adicionaremos o struts2-dojo-plugin.jar no classpath (WEB-INF/lib).

Assim, a seguinte a lista dos arquivos JAR necessrios. Observe que estes jars so necessrios para rodar

toda a aplicao, incluindo todos os exemplos das partes anteriores desta srie de tutoriais.

Ns vamos criar uma classe action a qual ir ser chamada pelo nosso exemplo Ajax. Crie um arquivo
AjaxAutocomplete.java no pacote net.viralpatel.struts2 e copie o seguinte contedo dentro dele.
AjaxAutocomplete.java
package net.viralpatel.struts2;

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import com.opensymphony.xwork2.ActionSupport;

public class AjaxAutocomplete extends ActionSupport {

private String data = "Afghanistan, Zimbabwe, India, United States, Germany, China,
Israel";
private List<String> countries;
private String country;

public String execute() {

countries = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(data, ",");

while (st.hasMoreTokens()) {
countries.add(st.nextToken().trim());
}
return SUCCESS;
}
public String getCountry() {
return this.country;
}

public List<String> getCountries() {

return countries;
}

public void setCountries(List<String> countries) {

this.countries = countries;
}
public void setCountry(String country) {
this.country = country;
}
}

No cdigo acima ns criamos uma simples classe action com os atributos String country e List
countries. A lista de pases ser populada com nomes de pases quando o mtodo execute() chamado.
Aqui por exemplo, ns carregamos dados estticos. Voc pode se sentir livre para mudar isso e adicionar
dados do banco de dados.
P

Crie o arquivo JSP para exibir o Textbox com Autocomplete para nossa action Ajax. Crie AjaxDemo.jsp no
diretrio WebContent.
AjaxDemo.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<%@ taglib prefix="sx" uri="/struts-dojo-tags"%>
<html>
<head>

<title>Welcome</title>
<sx:head />
</head>
<body>
<h2>Struts 2 Autocomplete (Drop down) Example!</h2>

Country:
<sx:autocompleter size="1" list="countries" name="country"></sx:autocompleter>
</action>
</body>
</html>

No arquivo JSP acima ns usamos a tag sx:autocompleter para renderizar um drop down com autocomplete
o qual utiliza a classe Ajax para buscar dados internamente. Veja que ns mapeamos o atributo list com
List countries.
P

Adicione a seguinte entrada de action no arquivo Struts.xml:

<action name="ajaxdemo" class="net.viralpatel.struts2.AjaxAutocomplete">
<interceptor-ref name="loggingStack"></interceptor-ref>
<result name="success" type="tiles">/ajaxdemo.tiles</result>
<result type="tiles">/ajaxdemo.tiles</result>
</action>

Observe que ns estamos utilizando Tiles aqui neste exemplo. Voc pode querer usar o AjaxDemo.jsp ao
invs do /ajaxdemo.tiles para renderizar a sada diretamente em JSP.

Compile e rode a aplicao no eclipse

Clique aqui para fazer o download do cdigo fonte sem os JARs (24KB)
C

O framework Struts2 fornece uma ampla variedade de recursos para criar uma rica aplicao web. Nessa
srie de Struts2 ns vimos diferentes aspectos do Struts2 como introduo ao struts2, aplicao hello world,
framework de validao, plugin tiles, interceptadores do struts2, carga de arquivo e suporte a Ajax.
F