Struts 2

Transcrição

Struts 2

Struts 2
O framework Apache Struts 2 é uma estrutura elegante e extensível para
a criação de aplicações Web em Java. A estrutura foi projetada visando
otimizar o ciclo completo de desenvolvimento, desde construção a
implantação e manutenção das aplicações. Foi originalmente conhecido
como WebWork 2. Depois de trabalhar de forma independente durante
vários anos, as comunidades Struts e WebWork juntaram forças para
criar Struts 2. Esta nova versão é mais simples de usar e se aproxima da
ideia da qual o Struts foi concebido para ser.
Versão 1.0
Apostila destinada ao curso com carga horária de 20 (vinte) horas
Curso Struts 2
Sumário
1. Struts 2...................................................................................................................................3
Características do Struts 2.....................................................................................................3
Projeto Simplificado...........................................................................................................3
Classes de Ações Simplificadas........................................................................................3
Não existem mais os ActionForms....................................................................................3
Padrões inteligentes..........................................................................................................3
Melhores características das Tag......................................................................................4
Novos Detalhes..................................................................................................................4
Criando um Hello World em Struts 2.....................................................................................4
Criação de estrutura de diretórios para o projeto..............................................................4
2. Configurações........................................................................................................................5
Arquivo web.xml.....................................................................................................................5
Arquivo struts.xml...................................................................................................................6
Arquivo struts-config.xml:.......................................................................................................7
Arquivo struts.properties........................................................................................................8
3. Actions....................................................................................................................................9
Camada Action.......................................................................................................................9
Camada Visão......................................................................................................................10
4. Templates.............................................................................................................................12
5. Ajax com Struts....................................................................................................................14
Implementação de Janela de Login com o Ajax (DOJO).....................................................14
6. Validação e Conversão........................................................................................................17
Validação..............................................................................................................................17
Conversão............................................................................................................................20
7. Struts e Spring......................................................................................................................25
8. Formulário Master/Detail......................................................................................................28
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l – A s a S u l , B ra s í l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
2 de 31
Curso Struts 2
1. Struts 2
Um framework é responsável por automatizar as tarefas mais comuns e fornecer uma
plataforma na qual os usuários criam rapidamente seus aplicativos. Struts 2 foi baseado no
framework OpenSymphony WebWork. Implementa o padrão de projeto Modelo – Visão –
Controle (MVC – Model-View-Control).
Em Struts 2 o modelo de exibição, e o controlador são implementadas pelo resultado da
ação de um FilterDispatcher (que realiza o trabalho do controlador). O trabalho do
Controlador é mapear a solicitação do usuário e tomar as medidas cabíveis. A camada de
Modelo contém os dados e a lógica de negócios que é implementado pelo componente de
ação. A camada de visão é o componente de apresentação que é comumente implementado
usando os padrões JSP, Velocity Template, Freemaker ou qualquer outra tecnologia de
apresentação.
Características do Struts 2
Projeto Simplificado
Programação das classes abstratas em vez de interfaces era um problema do projeto do
Struts 1 que foi resolvido no Struts 2. A maioria das classes agora são baseadas em
interfaces e na maioria, essas interfaces são o núcleo independente de HTTP. As classes
Actions do Struts 2 são uma estrutura independente e simplificada para o uso com POJOs
simples.
Classes de Ações Simplificadas
As classes Actions agora são simples POJOs. Qualquer classe Java que possua o método
execute() pode ser usada como uma classe no modelo Action. Não necessita implementar
qualquer interface. A Inversão de Controle (IoC) agora é automaticamente introduzida
durante o desenvolvimento das classes Actions.
Não existem mais os ActionForms
A característica dos ActionForms não é mais reconhecida para o Struts 2. Sendo
substituídas por simples JavaBean que são utilizados para colocar as propriedades
diretamente. Não é preciso usar todas as propriedades.
Padrões inteligentes
Os elementos de configuração possuem um valor padrão que pode ser definido de acordo
com a necessidade. Ainda existem arquivos baseados em padrão XML de configuração que
pode ser substituído de acordo com a necessidade. Ao contrário dos ActionForwards, os
Results fornecem uma maior flexibilidade para criar múltiplos tipos de saídas.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
3 de 31
Curso Struts 2
Melhores características das Tag
Agora as tags permitem adicionar capacidades de estilo sheet-driven, para que possamos
criar páginas mais consistentes e com menos código. As tags são mais capazes e orientada
para resultados. Podem ser ser alteradas para uma folha de estilo subjacente. A marcação
individual da tag pode ser alterada editando um modelo FreeMarker.
Novos Detalhes
Utilização de anotações Java 5 como uma alternativa para XML e configuração de
propriedades Java. O componente Checkbox não necessita mais de um tratamento especial
para os valores falsos. Muitas mudanças podem ser feitas na hora, sem a necessidade de
reiniciar o contêiner web.
Criando um Hello World em Struts 2
Vamos desenvolver a aplicação tipo “Olá Mundo” usando o framework Struts 2. Nossa
aplicação será o primeiro passo para que possamos compreender as modificações que
ocorreram com este framework.
Criação de estrutura de diretórios para o projeto
Realizar o download do Struts 2 e cópiar o arquivo struts2-blank-2.0.6.war para o diretório
webapps do Tomcat. Renomear o arquivo struts2-blank-2.0.6.war para struts2tutorial.rar
e descompactá-lo. Agora inicie o Tomcat e acesse o endereço:
http://localhost:8080/struts2tutorial/
No seu navegador mostrará:
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
4 de 31
Curso Struts 2
2. Configurações
A Configuração básica necessária para o framework Struts 2 depende da configuração dos
seguintes arquivos: struts.xml, web.xml, struts-config.xml e struts.properties.
Arquivo web.xml
O arquivo de configuração web.xml é um arquivo de configuração Java EE que determina
como os elementos da solicitação HTTP são processados pelo servlet container. Não é
estritamente um arquivo de configuração do Struts 2, mas é um arquivo que precisa ser
configurado para que o Struts 2 possa trabalhar corretamente.
Este arquivo fornece um ponto de entrada para qualquer aplicação Web. O ponto de entrada
de uma aplicação Struts 2 será um filtro definido no descritor de deployment. Desta forma,
vamos definir uma entrada de classe FilterDispatcher no arquivo web.xml. O arquivo
web.xml deve ser criada sob a pasta WebContent/WEB-INF. Vejamos um exemplo do
arquivo web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
Para mapear o filtro do Struts 2, usamos /*, e não /*.action o que significa que todas as urls
serão analisadas pelo filtro do Struts.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
5 de 31
Curso Struts 2
Arquivo struts.xml
O arquivo struts.xml contém as informações de configuração que devemos modificar como
as ações que são desenvolvidas. Este arquivo pode ser usado para substituir as
configurações padrões de um aplicativo, por exemplo
struts.devMode = false
E outras configurações que são definidas no arquivo de propriedades. Este arquivo pode ser
criado na pasta WEB-INF/classes. Vejamos um exemplo do arquivo struts.xml:
<!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.devMode" value="true" />
<package name="helloworld" extends="struts-default">
<action name="hello"
class="com.tutorialspoint.struts2.HelloWorldAction"
method="execute">
<result name="success">/HelloWorld.jsp</result>
</action>
<-- more actions can be listed here -->
</package>
<-- more packages can be listed here -->
</struts>
A primeira coisa a notar é o elemento DOCTYPE. Todo o arquivo XML necessita ter um
elemento doctype correto, conforme mostrado no código. <struts> é a tag raiz, no qual
podemos declarar diferentes pacotes usando a tag <package>, isso permite a separação e
a modularização da configuração. O que vem a ser muito útil quando temos um grande
projeto dividido em diferentes partes.
Digamos que, seu projeto possua três domínios: Negocio, Cliente e Pessoal, então podemos
criar três pacotes e armazenar as ações associadas no pacote apropriado. A tag <package>
possui os seguintes atributos:
Atributo
Descrição
name (obrigatório)
O identificador exclusivo para o pacote
extends
Nome do pacote herdado. Por padrão, usamos struts-default, como o
pacote base
abstract
Se marcado como “true”, o pacote não está disponível para o usuário
final
namespace
Nome único para as ações
A tag <constant> juntamente com os atributos nome e valor são usados para substituir
qualquer uma das seguintes propriedades definidas no default.properties, como acabamos
de definir na propriedade struts.devMode. Definir esta propriedade permite ver as
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
6 de 31
Curso Struts 2
mensagens de depuração no arquivo de log.
Definimos as tags <action> correspondete a cada URL que desejamos acessar e definimos
uma classe com método execute() que é acessado ao acessarmos a URL correspondente.
A tag <result> determina o que é retornado para o navegador após uma ação for executada.
A ação retorna um objeto do tipo String que contém o nome de um resultado. Essas tags são
configuradas por ação ou como um resultado "global", disponível para cada ação em um
pacote. Os resultados têm nome opcional e atributos de tipo. Usamos a String "sucess"
como o nome de valor padrão .
O arquivo struts.xml pode ficar muito grande ao longo do tempo, então é possível quebrá-lo
por pacotes, o que é uma forma de modularizar, mas a Struts 2 oferece uma nova maneira
de modularizar o arquivo struts.xml. É possível dividi-lo em vários arquivos XML e importálos da seguinte forma:
<struts>
<include file="my-struts1.xml"/>
<include file="my-struts2.xml"/>
</struts>
Arquivo struts-config.xml:
O arquivo de configuração struts-config.xml é a ligação entre a Visão e os componentes do
modelo no Cliente Web. Contém os seguinte elementos principais:
Interceptor
Descrição
struts-config
Nó raiz do arquivo de configuração.
form-bean
Local para mapear sua subclasse ActionForm. Pode-se usar este nome
como um alias para a ActionForm todo o resto do arquivo strutsconfig.xml, e até mesmo nas páginas JSP.
global forwards
Esta seção mapeia uma página em seu webapp para um nome. Pode-se
usar este nome para se referir à página real. Isso evita codificar URLs
em suas páginas Web.
action-mappings
Declaração do manipuladores de formulários e onde também são
conhecidos como mapeamentos de ação.
controller
Esta seção configura as internas do Struts e raramente é usada em
situações práticas.
plug-in
Esta seção informa ao Struts onde encontrar seus arquivos de
propriedades, que contêm instruções e mensagens de erro
Vejamos um exemplo do arquivo struts-config.xml:
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
7 de 31
Curso Struts 2
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
<struts-config>

<form-beans>
<form-bean name="login" type="test.struts.LoginForm" />
</form-beans>

<global-forwards>
</global-forwards>

<action-mappings>
<action path="/login"
type="test.struts.LoginAction" >
<forward name="valid" path="/jsp/MainMenu.jsp" />
<forward name="invalid" path="/jsp/LoginView.jsp" />
</action>
</action-mappings>

<controller contentType="text/html;charset=UTF-8"
debug="3"
maxFileSize="1.618M"
locale="true"
nocache="true"/>
</struts-config>
Arquivo struts.properties
Este arquivo de configuração fornece um mecanismo para alterar o comportamento padrão
do framework. Todas propriedades contidas neste arquivo também podem ser configuradas
no web.xml usando o param-init, bem como usando a tag <constant> no arquivo
struts.xml. Para manter os detalhes separados e um suporte mais específico, podemos
criar este arquivo na pasta WEB-INF/classes.
Os valores configurados neste arquivo substituem os valores padrões configurados em
default.properties que estão contidos na distribuição struts2-core-x.y.z.jar. Existem
propriedades que podem ser modificadas usando o arquivo struts.properties:
### Ao ser definido como verdadeiro, mostra as mensagens padrões
struts.devMode = true
### Permite a releitura dos arquivos de internacionalização
struts.i18n.reload = true
### Permite a releitura dos arquivos de configuração XML
struts.configuration.xml.reload = true
### Define a porta que o servidor é executado
struts.url.http.port = 8080
A linha iniciada com com o caracter “#”, será assumida como um comentário e ignorada pelo
Struts 2.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
8 de 31
Curso Struts 2
3. Actions
Actions são o ponto central do framework Struts 2, bem como para qualquer framework
modelo MVC (Model View Controller). Cada URL é mapeada para uma action específica,
que fornece a lógica de processamento necessária para atender à solicitação do usuário.
Actions possuem duas outras capacidades importantes. Primeiro, uma action desempenha
um papel importante na transferência de dados a partir do pedido através do ponto de vista,
se o seu tipo um JSP ou outro resultado. Em segundo lugar, o recurso deve ajudar o quadro
para determinar qual resultado deve tornar a visão de que será devolvido na resposta ao
pedido.
Camada Action
O único requisito para as actions em Struts 2 é que deve haver um método sem argumento
que retorna um objeto String ou um elemento Result e deve ser um POJO. Se o método
não-argumento não for especificado, o comportamento padrão é usar o método execute().
Opcionalmente, pode-se estender a classe ActionSupport que implementa seis interfaces,
incluindo a interface Action. Esta interface é mostrada como se segue:
public interface Action {
public static final String SUCCESS = "success";
public static final String NONE = "none";
public static final String ERROR = "error";
public static final String INPUT = "input";
public static final String LOGIN = "login";
public String execute() throws Exception;
}
Vamos dar uma olhada no método de ação para um exemplo "Hello World":
package x25.com.tutorial;
public class HelloWorldAction{
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Para ilustrar o ponto que o método da action controla a visão, faremos a seguinte alteração
no método execute() e estender a classe ActionSupport como segue:
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
9 de 31
Curso Struts 2
import com.opensymphony.xwork2.ActionSupport;
public class HelloAction extends ActionSupport{
private String nome;
if ("SECRET".equals(nome)) {
return SUCCESS;
} else {
return ERROR;
}
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Neste exemplo, temos a seguinte lógica para o método execute() de modo a visualizar o
atributo nome. Se este atributo for igual a "SECRET", retornamos SUCESS como o
resultado, caso contrário retornamos um ERROR como o resultado. Porque estendemos
ActionSupport, para isso usamos as constantes SUCESS e ERROR. Agora, vamos
modificar nosso arquivo struts.xml como segue:
<struts>
<package name="helloworld" extends="struts-default">
<action name="hello" class="x25.com.tutorial.HelloAction" method="execute">
<result name="success">/HelloWorld.jsp</result>
<result name="error">/AccessDenied.jsp</result>
</action>
</package>
</struts>
Camada Visão
Criamos o arquivo chamado HelloWorld.jsp na pasta raiz do seu projeto. Este arquivo será
chamado em caso do retorno ter como resultado "SUCESS", tal como definido na interface
Action:
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
10 de 31
Curso Struts 2
<title>Hello World</title>
</head>
<body>
Olá Mundo, <s:property value="name"/>
</body>
</html>
Este outro arquivo será chamado pelo framework no caso que o resultado da Action seja
ERROR. A seguir é o conteúdo de AccessDenied.jsp:
<%@ page contentType="text/html; charset=UTF-8" %>
<html>
<head>
<title>Acesso Bloqueado</title>
</head>
<body>
Você não está autorizado a ver esta página.
</body>
</html>
Também precisamos criar o arquivo index.jsp na pasta raiz. Este arquivo será utilizado
como ação inicial onde o usuário informa o nome e submete o formulário chamando o
método da classe HelloAction e tornar a visão HelloWorld.jsp.
<%@page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<%@taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World com Struts 2</h1>
<form action="hello">
<label for="nome">Por favor entre com seu nome</label><br/>
<input type="text" name="nome"/>
<input type="submit" value="Diga Hello"/>
</form>
</body>
</html>
Não existe qualquer mudança necessária no arquivo web.xml. Execute o aplicativo através
do endereço http://localhost:8080/struts2tutorial.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
11 de 31
Curso Struts 2
4. Templates
Templates são carregadas prioritariamente, pesquisando a aplicação e depois por procurar
o classpath. Se uma Template precisa de ser substituída, uma cópia é editada e pode ser
colocada na aplicação, de modo que seja encontrada.
Em muitas áreas o Struts 2 permaneceu praticamente inalterado depois de sua junção com
o Webwork. É possível ter uma Template para o controle da aparência de suas tags em um
nível de granulação fina ou em nível de aplicativo. Supondo o suporte a boas práticas e cada
tag <input> possua uma tag <label>, conforme a seguinte codificação:
<label for="nome">Nome</label>
<input type="text" name="nome" id="nome"/>
Embora possamos escrever uma tag <label> para cada tag <input> manualmente para
conseguir essa boa prática, podemos especificar uma Template para renderizar as tags
<s:textfield> de modo a reduzir a codificação escrita na JSP.
Criar uma Template chamada text.ftl no pasta template/mySimpleTheme e certifique-se
que está na classpath. Codificação text.ftl:
<label
<#if parameters.id?exists>
for="${parameters.id?html}" <#t/>
</#if>
>${parameters.label?html}</label>
<#include "/${parameters.templateDir}/simple/text.ftl" />
O arquivo de inclusão está apontando para um modelo bare-bones disponibilizado com o
Struts que torna um simples <input type="text"/> com todos seus atributos. Tudo o que
estamos fazendo no código adicional é uma verificação da existência de um id sendo
passado através da tag <textfield> e mostrá-lo em uma tag <label> juntamente com seu
valor que está sendo passado. Agora temos tem uma Template para trabalhar, tudo o que
resta a fazer é utilizá-la. Esta é uma maneira que pode aplicá-la a um único campo de texto:
<s:textfield id="nome" name="nome" theme="mySimpleTheme" label="Nome"/>
A declaração do tema "mySimpleTheme" está informando ao Struts procurar uma Template
no diretório mySimpleTheme sob o diretório padrão de Templates. Para este modelo
processar todos as tags <TextField> em vez de especificar theme="mySimpleTheme" todas
as vezes, devemos modificar as propriedades struts.ui.theme e struts.ui.templateDir no
arquivo struts.properties que possuem como valores padrões de xhtml e template,
respectivamente.
O tema padrão do Struts é xhtml que renderiza as tags <td> e <tr> e tudo o mais que é
indesejável na marcação. Para desativar essa renderização e os atributos de tag, podemos
utilizar o tema "simple" como a seguinte codificação:
<s:textfield id="nome" name="nome" theme="simple" label="Nome"/>
Alternativamente, podemos definir o atributo struts.ui.theme para “simple” no arquivo
struts.properties. Também podemos definir o atributo template de cada controle para
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
12 de 31
Curso Struts 2
apontar para um outro diretório.
Resumidamente, o Struts fornece templates padrões no arquivo struts-core.jar deve
atender às necessidades de muitas aplicações. No entanto, se uma template precisa ser
modificada, é fácil conectar uma nova versão. Para extrair uma template é necessária
mudar a partir do struts-core.jar, faça as modificações e salve uma cópia atualizada na
pasta template/$theme/$template.ftl. Se estiver utilizando o tema XHMTL e precisa mudar
a forma como as tags selecionem e renderizam, editar esse modelo e salve-o em
/template/xhtml/select.ftl.
O mecanismo global para controlar a aparência é completamente diferente do Struts 1.x
sendo um pouco mais complexa do que pode ser necessário para muitos projetos. Porém
permite uma maior liberdade para ajustar as templates de modo a atender qualquer caso.
Este é um método de baixo nível para controlar a aparência de um controle CSS. Struts usa
arquivos CSS na renderização de sua construção. Temas como xhtml são modificados para
xhtml_css, embora essa renomeação possa não ser um bom padrão. Por exemplo, ao usar
o seu tema xhtml_css e <s:textfield>, é necessário escrever classes CSS chamadas
wwgrp e wwlbl para controlar a exibição das tags <label> e <input>.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
13 de 31
Curso Struts 2
5. Ajax com Struts
Desenvolvedores do Ajax sabem que as tabelas podem fazer muito mais do que a exibição
estática informações em um formato organizado, legível. Ao sincronizar-se as linhas da
tabela com um banco de dados do lado do servidor, é possível criar tabelas dinâmicas desse
tipo, filtrar dados e realizar paginação.
Diversas soluções Ajax possuem a vantagem de simplificar a programação, convertendo o
código do servidor Java em JavaScript, normalmente à custa da flexibilidade. A maioria dos
desenvolvedores não querem ter o modelo de programação restringido pelo número limitado
de componentes que essas estruturas fornecem. Neste quisito, criar conteúdo personalizado
com Struts 2 e Ajax realmente é a melhor escolha, pois Struts 2 integra poderosos aliados
para fazer o desenvolvimento Ajax tornar-se prazer.
Implementação de Janela de Login com o Ajax (DOJO)
Vejamos como desenvolver uma aplicação de Login usando o Ajax. Nesta aplicação é
mostrado um formulário para autenticar um usuário, solitando o nome e a senha (O nome de
login e senha é "admin"). Exibe uma página de boas vindas, quando ambos os campos
forem corretamente preenchidos pelo usuário. Caso contrário, mostra uma mensagem de
erro e debug (nome de usuário e senha inválidos Por favor, tente novamente e DEBUG:
widget ID collision on ID: ajaxLogin_0).
Inicialmente, criamos um mapeamento de ação no arquivo struts.xml. Aqui está o código
para ser adicionado neste arquivo:
<action name="showAjaxLoginForm">
<result>/pages/ajaxlogin.jsp</result>
</action>
<action name="ajaxLogin" class="net.roseindia.Login">
<result name="input">/pages/ajaxlogin.jsp</result>
<result name="error">/pages/ajaxlogin.jsp</result>
<result>/pages/ajaxloginsuccess.jsp</result>
</action>
A interface gráfica do aplicativo consiste em um formulário de login (ajaxlogin.jsp), que
exibe a página de login para o usuário. Esta página usa a tag <s:div> que cria uma área de
conteúdo para carregar o conteúdo utilizando tags do Ajax. Aqui também usamos a tag
<s:submit> para atualizar o(s) elemento(s) ou que apresente uma mensagem de ajuda.
Sempre que ocorre um erro as tags <s:actionerror> e <s:fielderror> exibem uma
mensagem no formulário de login.
Página: ajaxlogin.jsp
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<s:head theme="ajax" debug="true"/>
</script>
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
14 de 31
Curso Struts 2
</head>
<body>
<s:div id="loginDiv" theme="ajax">
<div style="width: 300px;border-style: solid">
<s:form action="ajaxLogin" validate="true">
<tr>
<td colspan="2">Entrada no Sistema</td>
</tr>
<tr>
<td colspan="2"><s:actionerror /><s:fielderror /></td>
</tr>
<s:textfield name="username" label="Nome"/>
<s:password name="password" label="Senha"/>
<s:submit theme="ajax" targets="loginDiv" notifyTopics="/ajaxLogin"/>
</s:form>
</div>
</s:div>
</body>
</html>
Devemos agora, desenvolver uma classe de ação que trata a solicitação de login e verifica a
autenticação do usuário. Se o nome do usuário e senha for "Admin", então retorna SUCESS
caso contrário o objeto ERROR.
Bean de Ação: Login.java
import java.util.Date;
public class Login extends ActionSupport {
private String username = null;
private String password = null;
System.out.println("Validando o Login...");
if ("Admin".equals(getUsername()) && "Admin".equals(getPassword()) {
return SUCCESS;
}
addActionError("Usuário ou senha inválida! Tente novamente!");
return ERROR;
}
public String getUsername() {
return username;
}
public void setUsername(String value) {
username = value;
}
public String getPassword() {
return password;
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
15 de 31
Curso Struts 2
}
public void setPassword(String value) {
password = value;
}
}
A página ajaxloginsuccess.jsp exibe a mensagem de sucesso do Login (Bem Vindo
Admin) quando o usuário é autenticado com êxito.
Página: ajaxloginsuccess.jsp
<html>
<head>
<title>Login com Sucesso</title>
</head>
<body>
<p align="center">
<font color="#000080" size="5">Login realizado com sucesso !</font>
</p>
<h1> Bem Vindo <%=request.getParameter("username")%> </h1>
</body>
</html>
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
16 de 31
Curso Struts 2
6. Validação e Conversão
Um Validador (validator) verifica automaticamente se um erro de conversão ocorreu para
um determinado campo. Uma conversão de tipo no framework é transparente. Geralmente,
tudo o que é necessário fazer é garantir as entradas HTML possuem nomes que podem ser
usados em expressões OGNL.
Validação
Neste exemplo, veremos como podemos validar uma página de login usando as validações
do Struts 2. Para criarmos a página de login, as tags da interface do Struts. A tag <s:head>
deve ser colocada na seção head da página HTML, esta tag gera automaticamente links
para as bibliotecas de CSS e Javascript que são necessários para processar os elementos
do formulário.
A tag <s:form> contém os elementos do formulário. O atributo action contém o nome da
ação que deve ser executada quando o formulário for submetido. Este nome da ação deve
ser igual ao especificado no arquivo de configuração struts.xml.
O tag <s:textfield> é usada para criar uma caixa de texto. O atributo label dessa tag contém
o nome a ser exibido na página e o atributo name contém o nome da propriedade na classe
da ação a ser mapeado. A tag <s:password> é idêntica a tag <s:textfield> excepto que o
valor de entrada é mascarado. A tag <s:submit> é usada para criar um botão de submissão
(envio do formulário).
Página: login.jsp
<%@taglib uri="/struts-tags" prefix="s" %>
<head>
<title>Página Login</title>
<s:head />
</head>
<body>
<s:form action="Login">
<s:textfield name="userName" label="Usuário" />
<s:password name="password" label="Senha" />
<s:submit value="Entrar" />
</s:form>
</body>
Quando o usuário clicar no botão “Entrar” o pedido será encaminhado para a ação Login.
Devemos realizar o mapeamento desta ação no arquivo struts.xml.
<package name="default" extends="struts-default">
<action name="Login" class="x25.com.tutorial.Login">
<result name="input">/login.jsp</result>
<result name="success">/success.jsp</result>
</action>
</package>
Aqui o nosso pacote "padrão" estende o pacote "struts-default". Ao estender o "strutsS G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l – A s a S u l , B ra s í l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
17 de 31
Curso Struts 2
default" o pacote herda o conjunto de interceptores definido no defaultstack. O pacote
"struts-default" é definido no arquivo struts-default.xml. Todas as tarefas comuns são
realizadas pelas ações e separadas e colocadas em interceptores diferentes. Pode-se definir
um interceptador para cada ação. Os interceptores mais comuns são utilizados agrupados
em uma pilha defaultstack do pacote “struts-default”. O defaultstack será suficiente na
maioria dos casos. Os interceptores serão disparados na ordem em que são declarados na
pilha, tanto antes como após a acção é executada.
Aqui, a ação "Login" é mapeado para a classe "Login" do pacote “x25.com.tutorial”. Os
resultados são definidos usando o elemento "<result>". Se algum erro de validação ocorrer
o usuário será encaminhado para a página login.jsp. Se o login for bem sucedido, então o
usuário será encaminhado para a página sucesso.jsp.
O defaultstack contém os seguintes interceptores:
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="profiling"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params">
<param name="excludeParams">dojo\..*,^struts\..*</param>
</interceptor-ref>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="workflow">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
</interceptor-stack>
A classe de ação Login estende ActionSupport. Estender a classe ActionSupport fornece
a implementação padrão para a maioria das tarefas comuns.
public class Login extends ActionSupport {
private String userName;
private String password;
public Login() { }
public String execute() {
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
18 de 31
Curso Struts 2
return SUCCESS;
}
public void validate() {
if (getUserName().length() == 0) {
addFieldError("userName", "Nome é obrigatório");
} else if (!getUserName().equals("Admin")) {
addFieldError("userName", "Usuário Inválido");
}
if (getPassword().length() == 0) {
addFieldError("password", getText("password.required"));
}
}
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;
}
}
A classe implementa a interface ActionSupport que expõe o método execute(). As
seguintes constantes são declarados na interface de ação que podem ser usadas como
valores de retorno do método execute().
public
public
public
public
public
static
static
static
static
static
final
final
final
final
final
String
String
String
String
String
ERROR = "error"
INPUT = "input"
LOGIN = "login"
NONE = "none"
SUCCESS = "success"
São os seguintes valores:
•
ERROR devolvido quando a execução da ação falha
•
INPUT devolvido quando a ação exige a entrada do usuário.
•
LOGIN devolvido quando o usuário não estiver logado no sistema.
•
NONE devolvido quando a execução da ação for bem sucedida e não existem visões
para mostrar.
•
SUCCESS devolvido quando a ação for executada com êxito e o resultado
correspondente é exibido para o usuário.
Agora vamos ver os papéis desempenhados pelos diferentes interceptores.
•
O interceptor params ajuda em transferir os dados da solicitação para o objeto da
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
19 de 31
Curso Struts 2
ação.
•
O interceptor workflow controla o fluxo de controle. Verifica se a ação implementa a
interface Validateable, se isso acontecer, esse interceptor chamar o método
validate() da classe Action.
No método validate() valida o usuário e a senha. Se a validação falhar um erro é adicionado
usando o método addFiledError(). O método validate() não retorna nenhum erro, em vez
disso, armazena todos os erros com a ajuda da interface ValidationAware. Agora, o
interceptor workflow verifica os erros de validação ocorridos. Se algum erro ocorreu no
interceptor o processamento do pedido será interrompido e o controle é transferido para a
página de entrada com as mensagens de erro apropriadas.
Para cada campo, as mensagens de erro podem ser adicionadas usando o método
addFieldError(). As mensagens de erro pode ser adicionadas diretamente ou pode ser
especificado em um arquivo de propriedades separado.
Os arquivos de propriedades deve possuir o mesmo nome da classe Action. Neste caso o
nome do arquivo de propriedades é "Login.properties" já que o nome da ação é
"Login.java". Este arquivo deve conter a seguinte entrada:
password.required = Senha é obrigatória.
O método getText() é fornecido pela interface TextProvider e pode ser usado para retornar
as mensagens de erro.
Conversão
Conversão de tipo é ideal para as situações na qual precisamos transformar uma String em
um objeto mais complexo. Porque para a Web tudo é uma sequência em HTTP, Uma das
principais características do WebWork era uma conversão de tipo muito úteis. Por exemplo,
se o usuário estivesse acessando as coordenadas na forma de uma String (como "3, 22"),
podemos necessitar da conversão tanto de String para ponto como de ponto a String.
Usando este exemplo, se sua ação (ou outro objeto composto no qual está definindo em
propriedades) possui um arquivo ClassName-conversion.properties, Os conversores de
tipo configurados para conversão de e para strings. Transformar "3, 22" para o ponto (3, 22)
direcionamos a seguinte entrada para o arquivo de propriedades:
ponto = x25.com.converter.PontoConverter
Um exemplo de conversão de tipo é mostrado abaixo, usamos a conversão de data e
moeda, ao clicar no botão Enviar esses valores serão convertidos.
Página: Submit.jsp
<head>
<title>Formulário de Submissão</title>
<style type="text/css">@import url(css/main.css);</style>
<style>
.errorMessage { color:green; }
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
20 de 31
Curso Struts 2
</style>
<body>
<h2>Entre com os Dados</h2>
<s:form action="viewReport">
<s:textfield name="rollNo" label="Número"/>
<s:textfield name="name" label="Nome"/>
<s:textfield name="submissionDate" label="Data"/>
<s:textfield name="amount" label="Valor"/>
<s:submit/>
</s:form>
</body>
Página: Show.jsp
<head>
<title>Formulário de Submissão</title>
</head>
<body bgcolor="#9E9EE8">
<center>
<h2><u>Dados Inseridos</u></h2>
<table border="0" colspacing="5" colspading="15">
<tr>
<td>Número:</td>
<td><s:property value="rollNo"/></td>
</tr><tr>
<td>Nome:</td>
<td><s:property value="name"/></td>
</tr><tr>
<td>Valor:</td>
<td><s:property value="amount"/></td>
</tr><tr>
<td>Data:</td>
<td><s:date name="submissionDate" format="dd MMM yyyy"/></td>
</tr>
</table>
</center>
</body>
Classe de Ação: TypeConversionExample.java
package x25.com;
import java.util.Date;
public class TypeConversionExample extends ActionSupport{
private
private
private
private
private
String name;
int rollNo;
double amount;
Date submissionDate;
String datePattern="yyyy-mm-dd";
public String getDatePattern() {
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
21 de 31
Curso Struts 2
return datePattern;
}
public void setDatePattern(String datePattern) {
this.datePattern = datePattern;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRollNo() {
return rollNo;
}
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
public double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public Date getSubmissionDate() {
return submissionDate;
}
public void setSubmissionDate(Date submissionDate) {
this.submissionDate = submissionDate;
}
@Override
System.out.println(getSubmissionDate());
System.out.println(submissionDate);
return SUCCESS;
}
}
Depois de escrever uma classe de ação. Devemos passar os valores para o arquivo de
propriedades como:
Arquivo de Propriedade: TypeConversionExample-conversion.properties
submissionDate=x25.com.converter.DateConverterClaz
amount=x25.com.converter.CurrencyConverterClaz
Podemos criar no arquivo de propriedades as mensagem de erro apropriadas. Lembrando
que este arquivo deve ser do mesmo nome do arquivo de ação.
Arquivo de Propriedade: TypeConversionExample.properties
invalid.fieldvalue.amount=Favor entrar com o valor correto
invalid.fieldvalue.submissionDate=Favor entrar com a da no formato yyyy-mm-dd
Agora vamos codificar as classes que convertem os tipos.
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
22 de 31
Curso Struts 2
Classe de Conversão: DataConverterClaz.java
package x25.com.converter;
import
import
import
import
import
import
import
java.text.DateFormat;
java.text.ParseException;
java.text.SimpleDateFormat;
java.util.Date;
java.util.Map;
ognl.DefaultTypeConverter;
com.opensymphony.xwork2.conversion.TypeConversionException;
public class DateConverterClaz extends DefaultTypeConverter {
private Date convertedDate;
public Date convertValue(Map context, Object object, Class type) {
if (type == Date.class) {
String datePattern = "yyyy-MM-dd";
DateFormat format = new SimpleDateFormat(datePattern);
format.setLenient(false);
try {
String[] dateString = (String[]) object;
convertedDate = format.parse(dateString[0]);
return convertedDate;
} catch (Exception e) {
e.toString();
throw new TypeConversionException("Data é inválida");
}
}
return null;
}
}
Classe de Conversão: CurrencyConverterClaz.java
package x25.com.converter;
import
import
import
import
import
java.lang.reflect.Member;
java.text.DecimalFormat;
java.text.NumberFormat;
java.util.Map;
com.opensymphony.xwork2.conversion.TypeConverter;
public class CurrencyConverterClaz implements TypeConverter{
privateStringBuilder stringBuilder;
public String replace(String string, char character, String convert) {
if (string == null)
return null;
int length = string.length();
stringBuilder= new StringBuilder(string.length() * 2);
for (int i = 0; i < length; i++) {
char char2 = string.charAt(i);
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
23 de 31
Curso Struts 2
if (char2 == character) {
stringBuilder.append(convert);
} else {
stringBuilder.append(char2);
}
}
return stringBuilder.toString();
}
@Override
public Object convertValue(Map<String, Object> arg0, Object arg1,
Member arg2, String arg3, Object value, Class type) {
if (value == null) {
return null;
}
else if (type == String.class) {
NumberFormat newCurrency = new DecimalFormat("#,##0.00");
String formatedCurrency=newCurrency.format((Double) value);
return formatedCurrency;
} else if (type == Double.TYPE || type == Double.class) {
String[] strings = (String[]) value;
String doubleValue = strings[0];
return Double.parseDouble(replace(doubleValue, ',', ""));
}
return null;
}
}
Por fim o arquivo de mapeamento.
Arquivo de Configuração: struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<struts>
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
<package name="x25" namespace="/" extends="struts-default">
<action name="showForm">
<result>/jsp/Submit.jsp</result>
</action>
<action name="viewReport" class="x25.com.TypeConversionExample">
<result name="input">/jsp/Submit.jsp</result>
<result name="success">/jsp/Show.jsp</result>
</action>
</package>
</struts>
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
24 de 31
Curso Struts 2
7. Struts e Spring
No método de execução onde muitas classes ActionSupport do Struts 2 são declarações e
criam objetos e depois temos de executar esses objetos e os métodos que executam as
tarefas necessárias. Sempre que uma classe cria um objeto de outra classe apresenta uma
dependência entre as duas classes. O framework Spring torna mais fácil para o
desenvolvedor de aplicativos gerenciar essas dependências e ajuda a tornar a aplicação
mais flexível e de fácil manutenção.
Vamos criar um exemplo para mostrar como funciona a integração Spring e Struts 2,
utilizando o struts2-spring-plugin. Ao fazer isso podemos utilizar o recurso de Injeção do
Spring.
Arquivo de Configuração: web.xml
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>Struts2Example14</display-name>
<filter>
<filter-class>
org.apache.struts2.dispatcher.ng.filter. StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<filter-mapping>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</web-app>
Por padrão o arquivo applicationContext.xml será utilizado para fazer a configuração do
bean Spring.
Arquivo de Configuração: applicationContext.xml
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
25 de 31
Curso Struts 2
<beans>
<bean id="helloWorldClass" class="x25.com.HelloWorld" >
<property name="message" value="Olá Mundo!" />
</bean>
</beans>
Registramos a classe HelloWorld e injetamos a mensagem "Olá Mundo!" para o atributo
message usando o método de injeção.
Arquivo de Propriedade: struts.xml
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration
2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="default" extends="struts-default">
<action name="helloWorld" class="helloWorldClass">
<result name="SUCCESS">/success.jsp</result>
</action>
</package>
</struts>
A única mudança é que em vez de se referir a classe x25.com.HelloWorld diretamente,
relacionamos a ela usando o nome do bean definido no arquivo de configuração do Spring
Bean. A classe HelloWorld é mostrada abaixo. No método execute() que simplesmente
retorna "SUCESS" e o atributo message é definido usando a injeção.
Classe POJO: HelloWorld.java
package x25.com;
public class HelloWorld {
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String execute() {
return "SUCCESS";
}
}
Na página index.jsp encaminhamos o pedido para a ação helloWorld.
Página: index.jsp
<META HTTP-EQUIV="Refresh" CONTENT="0;URL=helloWorld.action">
Depois de invocar o método execute() o usuário será direcionado para a página success.jsp.
Nesta página mostramos valor da mensagem. É necessário ter os seguintes arquivos JAR
no diretório WEB-INF/lib para que este exemplo seja executado corretamente:
commons-fileupload-1.2.1
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
26 de 31
Curso Struts 2
commons-io-1.3.2
commons-logging-1.1
freemarker-2.3.13
junit-3.8.1
ognl-2.6.11
struts2-convention-plugin-2.1.6
struts2-core-2.1.6
xwork-2.1.2
struts2-spring-plugin-2.1.6
antlr-runtime-3.0
org.springframework.asm-3.0.0.M3
org.springframework.beans-3.0.0.M3
org.springframework.context-3.0.0.M3
org.springframework.core-3.0.0.M3
org.springframework.expression-3.0.0.M3
org.springframework.web-3.0.0.M3
org.springframework.web.servlet-3.0.0.M3
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
27 de 31
Curso Struts 2
8. Formulário Master/Detail
Este é um simples exemplo Master-Detail. Uma lista de dados mestre é mantido em uma
lista e exibidos em uma tabela. Quando uma linha for selecionada com a visão de ligação de
um detalhe da tela JSP é aberta e o item selecionado é exibido. A lista é usada pela tabela
mestre é carregado com a ação no início da aplicação.
Arquivo de Configuração: web.xml
<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>Struts Blank</display-name>
<filter>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</web-app>
Página: index.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META HTTP-EQUIV="Refresh" CONTENT="0;URL=ars/setList.action">
</head>
<body>
<p>Lendo...</p>
</body>
</html>
Arquivo de Configuração: struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<struts>
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
<constant name="struts.devMode" value="false" />
<package name="ars" namespace="/ars" extends="struts-default">
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
28 de 31
Curso Struts 2
<action name="setList" class="ars.SetListAction">
<result name="success">/listProcess.jsp</result>
</action>
<action name="viewDetail" class="ars.ViewDetailAction">
<result name="success">/viewDetailProcess.jsp</result>
</action>
</package>
</struts>
Bean de Ação: SetListAction.java
package x25.com;
import
import
import
import
import
import
import
import
import
com.opensymphony.xwork2.ActionContext;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
com.opensymphony.xwork2.ActionSupport;
java.util.*;
javax.servlet.http.HttpSession;
org.apache.struts2.ServletActionContext;
org.apache.struts2.interceptor.ServletRequestAware;
org.apache.struts2.interceptor.ServletResponseAware;
public final class SetListAction extends ActionSupport implements
ServletRequestAware,ServletResponseAware {
private HttpServletRequest request;
private HttpServletResponse response;
private List list;
public SetListAction() {
request = getServletRequest();
}
HttpSession session = request.getSession();
list = new ArrayList();
list.add("Frutas");
list.add("Maçã");
list.add("Manga");
list.add("Laranja");
list.add("Tomate");
session.setAttribute("baseList",list);
return SUCCESS ;
}
public List getList(){
return list;
}
public void setServletRequest(HttpServletRequest request){
this.request = request;
}
public HttpServletRequest getServletRequest(){
return request;
}
public void setServletResponse(HttpServletResponse response){
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
29 de 31
Curso Struts 2
this.response = response;
}
public HttpServletResponse getServletResponse(){
return response;
}
}
Página: listProcess.jsp
<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
<html>
<head>
<title>Iterator</title>
</head>
<body>
<table border="2px" bgcolor="#CCCC99" cellspacing="1">
<s:iterator value="#session.baseList" id="iteratorItem">
<tr>
<td>Valor do Item:</td>
<td><s:property value="iteratorItem"/></td>
<td>
<s:url var="url" action="/viewDetail">
<s:param name="iteratorItem" value="iteratorItem"/>
</s:url>
<s:a href="%{url}">Detalhes</s:a>
</td>
</tr>
</s:iterator>
</table>
</body>
</html>
Bean de Ação: ViewDetailAction.java
package x25.com;
import
import
import
import
import
import
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
com.opensymphony.xwork2.ActionSupport;
javax.servlet.http.HttpSession;
org.apache.struts2.interceptor.ServletRequestAware;
org.apache.struts2.interceptor.ServletResponseAware;
public final class ViewDetailAction extends ActionSupport implements
ServletRequestAware, ServletResponseAware {
private HttpServletRequest request;
private HttpServletResponse response;
public ViewDetailAction() {
request = getServletRequest();
}
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
30 de 31
Curso Struts 2
HttpSession session = request.getSession();
String detailInfo = request.getParameter("iteratorItem");
session.setAttribute("baseDetail", detailInfo);
return SUCCESS;
}
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
public HttpServletRequest getServletRequest() {
return request;
}
public void setServletResponse(HttpServletResponse response) {
this.response = response;
}
public HttpServletResponse getServletResponse() {
return response;
}
}
Página: viewDetailProcess.jsp
<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
<html>
<head>
<title>Detalhes</title>
</head>
<body>
<s:text name="#session.baseDetail" />
</body>
</html>
C E P : 7 0 . 3 9 0 - 1 0 0 – Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 – 3 2 4 2 - 4 3 3 9
31 de 31

Struts 2

Transcrição

Documentos relacionados

Turorial em PDF

Lista5-INE5603-Strings

anexo xxxi - DFPC - Exército Brasileiro

formulário de solicitação de serviços eleitorais - Consulado

MANUAL PARA CONFIGURAR CLIENTE WinSCP 1 2 3

Programa de Pós-Graduação em Estudos Contemporâneos das

I authorize PASB to add to the next month`s tuition bill the amount

programação

Edital 20-2014 - Pensando o Direito

2014 年「稱心服務團隊獎」獲獎名單