Struts 2 - Guia rápido
Model View Controller ou MVCcomo é popularmente chamado, é um padrão de design de software para o desenvolvimento de aplicativos da web. Um padrão Model View Controller é composto das seguintes três partes -
Model - O nível mais baixo do padrão responsável por manter os dados.
View - É responsável por exibir todos ou parte dos dados ao usuário.
Controller - Código de software que controla as interações entre o modelo e a visualização.
MVC é popular porque isola a lógica do aplicativo da camada de interface do usuário e oferece suporte à separação de interesses. Aqui, o Controlador recebe todas as solicitações da aplicação e, em seguida, trabalha com o Modelo para preparar todos os dados necessários para a Visualização. A Visualização então usa os dados preparados pelo Controlador para gerar uma resposta final apresentável. A abstração MVC pode ser representada graficamente como segue.
O modelo
O modelo é responsável por gerenciar os dados do aplicativo. Ele responde à solicitação da visualização e também às instruções do controlador para se atualizar.
A vista
Significa a apresentação dos dados em um determinado formato, desencadeada pela decisão de um controlador de apresentar os dados. Eles são sistemas de modelos baseados em script como JSP, ASP, PHP e muito fáceis de integrar com a tecnologia AJAX.
O controlador
O controlador é responsável por responder à entrada do usuário e realizar interações nos objetos do modelo de dados. O controlador recebe a entrada, ele valida a entrada e, em seguida, executa a operação de negócios que modifica o estado do modelo de dados.
Struts2é uma estrutura baseada em MVC. Nos próximos capítulos, vamos ver como podemos usar a metodologia MVC no Struts2.
Struts2é uma estrutura de aplicativo da web popular e madura baseada no padrão de design MVC. Struts2 não é apenas uma nova versão do Struts 1, mas é uma reescrita completa da arquitetura Struts.
A estrutura do Webwork começou inicialmente com a estrutura do Struts como base e seu objetivo era oferecer uma estrutura aprimorada e aprimorada construída no Struts para tornar o desenvolvimento da web mais fácil para os desenvolvedores.
Depois de um tempo, a estrutura do Webwork e a comunidade Struts deram as mãos para criar a famosa estrutura Struts2.
Recursos do Struts 2 Framework
Aqui estão alguns dos excelentes recursos que podem forçá-lo a considerar o Struts2 -
POJO Forms and POJO Actions- O Struts2 eliminou os Formulários de Ação que eram parte integrante da estrutura do Struts. Com o Struts2, você pode usar qualquer POJO para receber a entrada do formulário. Da mesma forma, agora você pode ver qualquer POJO como uma classe Action.
Tag Support - Struts2 melhorou as tags de formulário e as novas tags que permitem aos desenvolvedores escrever menos código.
AJAX Support - O Struts2 reconheceu o controle das tecnologias Web2.0 e integrou o suporte AJAX ao produto criando tags AJAX, esta função é muito semelhante às tags Struts2 padrão.
Easy Integration - A integração com outros frameworks como Spring, Tiles e SiteMesh agora é mais fácil com uma variedade de integração disponível com Struts2.
Template Support - Suporte para geração de visualizações usando modelos.
Plugin Support- O comportamento principal do Struts2 pode ser aprimorado e aumentado pelo uso de plug-ins. Vários plug-ins estão disponíveis para Struts2.
Profiling- Struts2 oferece perfis integrados para depurar e criar perfis do aplicativo. Além disso, o Struts também oferece depuração integrada com a ajuda de ferramentas de depuração integradas.
Easy to Modify Tags- As marcações de tag no Struts2 podem ser ajustadas usando os modelos do Freemarker. Isso não requer conhecimento de JSP ou java. Conhecimento básico de HTML, XML e CSS é suficiente para modificar as tags.
Promote Less configuration- Struts2 promove menos configuração com a ajuda do uso de valores padrão para várias configurações. Você não precisa configurar nada, a menos que desvie das configurações padrão definidas pelo Struts2.
View Technologies - Struts2 tem um ótimo suporte para várias opções de visualização (JSP, Freemarker, Velocity e XSLT)
Listados acima estão os 10 principais recursos de Struts 2 o que o torna uma estrutura pronta para a empresa.
Desvantagens do Struts 2
Embora o Struts 2 venha com uma lista de ótimos recursos, existem algumas limitações da versão atual - Struts 2 que precisa de mais melhorias. Listados estão alguns dos pontos principais -
Bigger Learning Curve - Para usar MVC com Struts, você deve estar confortável com o JSP padrão, APIs de Servlet e uma estrutura grande e elaborada.
Poor Documentation - Em comparação com o servlet padrão e as APIs JSP, o Struts tem menos recursos online e muitos usuários iniciantes acham a documentação do Apache online confusa e mal organizada.
Less Transparent - Com os aplicativos Struts, há muito mais acontecendo nos bastidores do que com os aplicativos da Web baseados em Java normais, o que torna difícil entender a estrutura.
Nota final, um bom framework deve fornecer um comportamento genérico que muitos tipos diferentes de aplicativos possam fazer dele.
Struts 2 é um dos melhores frameworks web e é muito utilizado para o desenvolvimento de Rich Internet Applications (RIA).
Nossa primeira tarefa é colocar um aplicativo Struts 2 mínimo em execução. Este capítulo irá guiá-lo sobre como preparar um ambiente de desenvolvimento para iniciar seu trabalho com o Struts 2.
Presumo que você já tenha JDK (5+), Tomcat e Eclipse instalados em sua máquina. Se você não tiver esses componentes instalados, siga as etapas fornecidas rapidamente -
Etapa 1 - Configure o Java Development Kit (JDK)
Você pode baixar a versão mais recente do SDK no site Java da Oracle - Java SE Downloads . Você encontrará instruções para instalar o JDK nos arquivos baixados, siga as instruções fornecidas para instalar e configurar a configuração. Finalmente, defina as variáveis de ambiente PATH e JAVA_HOME para se referir ao diretório que contém java e javac, normalmente java_install_dir / bin e java_install_dir respectivamente.
Se você estiver executando o Windows e instalou o SDK em C: \ jdk1.5.0_20, deve inserir a seguinte linha em seu arquivo C: \ autoexec.bat.
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20Alternativamente, no Windows NT / 2000 / XP -
Você pode clicar com o botão direito do mouse em Meu Computador, Selecionar Propriedades, Avançado e Variáveis de ambiente. Em seguida, você atualizaria o valor de PATH e pressionaria o botão OK.
No Unix (Solaris, Linux, etc.), se o SDK for instalado em /usr/local/jdk1.5.0_20 e você usar o shell C, você deve colocar o seguinte em seu arquivo .cshrc.
No Unix (Solaris, Linux, etc.), se o SDK for instalado em /usr/local/jdk1.5.0_20 e você usar o shell C, você deve colocar o seguinte em seu arquivo .cshrc.
setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20Alternativamente, se você usar um Ambiente de Desenvolvimento Integrado (IDE) como Borland JBuilder, Eclipse, IntelliJ IDEA ou Sun ONE Studio, compile e execute um programa simples para confirmar que o IDE sabe onde você instalou Java, caso contrário, faça a configuração adequada de acordo com determinado documento do IDE.
Etapa 2 - Configurar Apache Tomcat
Você pode baixar a versão mais recente do Tomcat em https://tomcat.apache.org/. Depois de fazer o download da instalação, descompacte a distribuição binária em um local conveniente.
Por exemplo, em C: \ apache-tomcat-6.0.33 no Windows ou /usr/local/apachetomcat-6.0.33 no Linux / Unix e crie a variável de ambiente CATALINA_HOME apontando para esses locais.
Você pode iniciar o Tomcat executando os seguintes comandos em uma máquina Windows ou simplesmente clicar duas vezes em startup.bat
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batO Tomcat pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.shApós uma inicialização bem-sucedida, os aplicativos da web padrão incluídos no Tomcat estarão disponíveis visitando http://localhost:8080/. Se tudo estiver bem, ele deve exibir o seguinte resultado -
Mais informações sobre como configurar e executar o Tomcat podem ser encontradas na documentação incluída aqui, bem como no site do Tomcat: https://tomcat.apache.org/
O Tomcat pode ser interrompido executando os seguintes comandos na máquina Windows -
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownO Tomcat pode ser interrompido executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shEtapa 3 - Configurar Eclipse (IDE)
Todos os exemplos neste tutorial são escritos usando Eclipse IDE. Sugiro que você tenha a versão mais recente do Eclipse instalada em sua máquina.
Para instalar o Eclipse, faça download dos binários mais recentes do Eclipse em https://www.eclipse.org/downloads/. Depois de baixar a instalação, descompacte a distribuição binária em um local conveniente.
Por exemplo, em C: \ eclipse no windows, ou / usr / local / eclipse no Linux / Unix e finalmente defina a variável PATH apropriadamente. O Eclipse pode ser iniciado executando os seguintes comandos na máquina Windows ou você pode simplesmente clicar duas vezes em eclipse.exe
%C:\eclipse\eclipse.exeO Eclipse pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -
$/usr/local/eclipse/eclipseApós uma inicialização bem-sucedida, se tudo estiver bem, ele deve exibir o seguinte resultado -
Etapa 4 - Configurar Bibliotecas Struts2
Agora, se tudo estiver bem, você pode prosseguir com a configuração do seu framemwork Struts2. A seguir estão as etapas simples para baixar e instalar o Struts2 em sua máquina.
Escolha se deseja instalar o Struts2 no Windows ou Unix e, em seguida, prossiga para a próxima etapa para baixar o arquivo .zip para Windows e o arquivo .tz para Unix.
Baixe a última versão dos binários do Struts2 em https://struts.apache.org/download.cgi.
No momento de escrever este tutorial, eu baixei struts-2.0.14-all.zip e quando você descompactar o arquivo baixado, ele fornecerá a estrutura de diretório dentro de C: \ struts-2.2.3 como segue.
O segundo passo é extrair o arquivo zip em qualquer local, baixei e extraí struts-2.2.3-all.zip dentro c:\ pasta na minha máquina Windows 7 para que eu tenha todos os arquivos jar em C:\struts-2.2.3\lib. Certifique-se de definir sua variável CLASSPATH corretamente, caso contrário, você enfrentará problemas ao executar seu aplicativo.
De um alto nível, Struts2 é uma estrutura pull-MVC (ou MVC2). O padrão Model-ViewController no Struts2 é implementado com os seguintes cinco componentes principais -
- Actions
- Interceptors
- Pilha de valores / OGNL
- Resultados / tipos de resultados
- Ver tecnologias
Struts 2 é um pouco diferente de uma estrutura MVC tradicional, onde a ação assume o papel do modelo em vez do controlador, embora haja alguma sobreposição.
O diagrama acima mostra o Model, Vver e Controller para a arquitetura de alto nível Struts2. O controlador é implementado com umStruts2despachar filtro de servlet, bem como interceptores, este modelo é implementado com ações e a visualização é uma combinação de tipos de resultados e resultados. A pilha de valores e OGNL fornecem thread comum, vinculando e permitindo a integração entre os outros componentes.
Além dos componentes acima, haverá muitas informações relacionadas à configuração. Configuração para a aplicação web, bem como configuração para ações, interceptores, resultados, etc.
Esta é a visão geral da arquitetura do padrão Struts 2 MVC. Examinaremos cada componente com mais detalhes nos capítulos subsequentes.
Solicitar Ciclo de Vida
Com base no diagrama acima, você pode entender o fluxo de trabalho por meio do ciclo de vida da solicitação do usuário em Struts 2 como segue -
O usuário envia uma solicitação ao servidor para solicitar algum recurso (ou seja, páginas).
O Filter Dispatcher examina a solicitação e, em seguida, determina a Ação apropriada.
Funcionalidades de interceptor configuradas se aplicam como validação, upload de arquivo etc.
A ação selecionada é executada com base na operação solicitada.
Novamente, os interceptores configurados são aplicados para fazer qualquer pós-processamento, se necessário.
Finalmente, o resultado é preparado pela visualização e retorna o resultado ao usuário.
Como você já aprendeu com a arquitetura do Struts 2, quando você clica em um hiperlink ou envia um formulário HTML em um aplicativo da web do Struts 2, a entrada é coletada pelo Controlador que é enviada para uma classe Java chamada Actions. Depois que a ação é executada, um resultado seleciona um recurso para renderizar a resposta. O recurso geralmente é um JSP, mas também pode ser um arquivo PDF, uma planilha do Excel ou uma janela de miniaplicativo Java.
Supondo que você já tenha construído seu ambiente de desenvolvimento. Agora, vamos prosseguir para a construção de nosso primeiroHello World Struts2projeto. O objetivo deste projeto é construir uma aplicação web que coleta o nome do usuário e exibe "Hello World" seguido do nome do usuário.
Teríamos que criar os seguintes quatro componentes para qualquer projeto Struts 2 -
| Sr. Não | Componentes e descrição |
|---|---|
| 1 | Action Crie uma classe de ação que conterá lógica de negócios completa e controlará a interação entre o usuário, o modelo e a visualização. |
| 2 | Interceptors Crie interceptores, se necessário, ou use interceptores existentes. Isso faz parte do controlador. |
| 3 | View Crie um JSPs para interagir com o usuário para obter a entrada e apresentar as mensagens finais. |
| 4 | Configuration Files Crie arquivos de configuração para acoplar Action, View e Controllers. Esses arquivos são struts.xml, web.xml, struts.properties. |
Vou usar o Eclipse IDE, para que todos os componentes necessários sejam criados em um projeto da Web dinâmico. Vamos agora começar criando Dynamic Web Project.
Crie um projeto dinâmico da Web
Comece seu Eclipse e vá com File > New > Dynamic Web Project e insira o nome do projeto como HelloWorldStruts2 e definir o restante das opções conforme mostrado na tela a seguir -
Selecione todas as opções padrão nas próximas telas e, finalmente, verifique Generate Web.xml deployment descriptoropção. Isso criará um projeto da web dinâmico para você no Eclipse. Agora vá comWindows > Show View > Project Explorer, e você verá a janela do seu projeto como abaixo -
Agora copie os seguintes arquivos da pasta struts 2 lib C:\struts-2.2.3\lib para o nosso projeto WEB-INF\libpasta. Para fazer isso, você pode simplesmente arrastar e soltar todos os arquivos a seguir na pasta WEB-INF \ lib.
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Criar classe de ação
A classe de ação é a chave para o aplicativo Struts 2 e implementamos a maior parte da lógica de negócios na classe de ação. Então, vamos criar um arquivo java HelloWorldAction.java emJava Resources > src com um nome de pacote com.tutorialspoint.struts2 com o conteúdo fornecido abaixo.
A classe Action responde a uma ação do usuário quando o usuário clica em um URL. Um ou mais métodos da classe Action são executados e um resultado String é retornado. Com base no valor do resultado, uma página JSP específica é renderizada.
package com.tutorialspoint.struts2;
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;
}
}Esta é uma classe muito simples com uma propriedade chamada "nome". Temos métodos getters e setter padrão para a propriedade "name" e um método execute que retorna a string "success".
A estrutura do Struts 2 criará um objeto do HelloWorldActionclasse e chama o método executado em resposta à ação de um usuário. Você coloca sua lógica de negócios dentro desse método, que finalmente retorna a constante String. Em outras palavras, para cada URL, você teria que implementar uma classe de ação e pode usar esse nome de classe diretamente como seu nome de ação ou pode mapear para algum outro nome usando o arquivo struts.xml conforme mostrado abaixo.
Criar uma vista
Precisamos de um JSP para apresentar a mensagem final, esta página será chamada pelo framework Struts 2 quando ocorrer uma ação pré-definida e este mapeamento será definido no arquivo struts.xml. Então, vamos criar o arquivo jsp abaixoHelloWorld.jspna pasta WebContent em seu projeto eclipse. Para fazer isso, clique com o botão direito na pasta WebContent no explorador de projetos e selecioneNew >JSP File.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>A diretiva taglib informa ao recipiente Servlet que esta página usará o Struts 2 tags e que essas tags serão precedidas por s.
A tag s: property exibe o valor da propriedade da classe de ação "nome> que é retornado pelo método getName() da classe HelloWorldAction.
Criar página principal
Também precisamos criar index.jspna pasta WebContent. Este arquivo servirá como a URL de ação inicial em que um usuário pode clicar para dizer à estrutura do Struts 2 para chamar um método definido da classe HelloWorldAction e renderizar a visualizaçã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 From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>o helloa ação definida no arquivo de visualização acima será mapeada para a classe HelloWorldAction e seu método de execução usando o arquivo struts.xml. Quando um usuário clica no botão Enviar, isso fará com que a estrutura do Struts 2 execute o método execute definido na classe HelloWorldAction e, com base no valor retornado do método, uma visualização apropriada será selecionada e processada como uma resposta.
Arquivos de configuração
Precisamos de um mapeamento para amarrar a URL, a classe HelloWorldAction (modelo) e HelloWorld.jsp (a visualização). O mapeamento informa à estrutura do Struts 2 qual classe responderá à ação do usuário (a URL), qual método dessa classe será executado e qual visualização renderizar com base no resultado String que o método retorna.
Então, vamos criar um arquivo chamado struts.xml. Já que o Struts 2 requer que o struts.xml esteja presente na pasta de classes. Portanto, crie o arquivo struts.xml na pasta WebContent / WEB-INF / classes. O Eclipse não cria a pasta "classes" por padrão, então você precisa fazer isso sozinho. Para fazer isso, clique com o botão direito na pasta WEB-INF no explorador de projetos e selecioneNew > Folder. Seu struts.xml deve ser semelhante a -
<?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.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>
</package>
</struts>Poucas palavras que precisam ser entendidas em relação ao arquivo de configuração acima. Aqui, definimos a constantestruts.devMode para true, porque estamos trabalhando em um ambiente de desenvolvimento e precisamos ver algumas mensagens de log úteis. Então, definimos um pacote chamadohelloworld.
Criar um pacote é útil quando você deseja agrupar suas ações. Em nosso exemplo, nomeamos nossa ação como "olá", que corresponde ao URL/hello.action e é apoiado peloHelloWorldAction.class. oexecute método de HelloWorldAction.class é o método que é executado quando o URL /hello.actioné invocado. Se o resultado do método execute retornar "sucesso", então levamos o usuário paraHelloWorld.jsp.
O próximo passo é criar um web.xmlarquivo que é um ponto de entrada para qualquer solicitação ao Struts 2. O ponto de entrada do aplicativo Struts2 será um filtro definido no descritor de implantação (web.xml). Portanto, definiremos uma entrada da classe org.apache.struts2.dispatcher.FilterDispatcher em web.xml. O arquivo web.xml precisa ser criado na pasta WEB-INF em WebContent. O Eclipse já havia criado um arquivo web.xml esqueleto para você quando criou o projeto. Então, vamos modificá-lo da seguinte maneira -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Especificamos index.jsp para ser nosso arquivo de boas-vindas. Em seguida, configuramos o filtro Struts2 para ser executado em todos os urls (ou seja, qualquer url que corresponda ao padrão / *)
Para ativar o log detalhado
Você pode ativar a funcionalidade de registro completa enquanto trabalha com o Struts 2 criando logging.properties arquivo sob WEB-INF/classespasta. Mantenha as duas linhas a seguir em seu arquivo de propriedade -
org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandlerO logging.properties padrão especifica um ConsoleHandler para roteamento de log para stdout e também um FileHandler. O limite de nível de log de um manipulador pode ser definido usando SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST ou ALL.
É isso aí. Estamos prontos para executar nosso aplicativo Hello World usando a estrutura Struts 2.
Procedimento para executar o aplicativo
Clique com o botão direito no nome do projeto e clique Export > WAR File para criar um arquivo de guerra.
Em seguida, implante esse WAR no diretório webapps do Tomcat.
Finalmente, inicie o servidor Tomcat e tente acessar o URL http://localhost:8080/HelloWorldStruts2/index.jsp. Isso lhe dará a seguinte tela -
Insira um valor "Struts2" e envie a página. Você deve ver a próxima página
Observe que você pode definir index como uma ação no arquivo struts.xml e, nesse caso, você pode chamar a página de índice como http://localhost:8080/HelloWorldStruts2/index.action. Verifique abaixo como você pode definir o índice como uma ação -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "index">
<result >/index.jsp</result>
</action>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Este capítulo irá guiá-lo através da configuração básica que é necessária para um Struts 2inscrição. Aqui veremos o que pode ser configurado com a ajuda de alguns arquivos de configuração importantes comoweb.xml, struts.xml, strutsconfig.xml e struts.properties
Honestamente falando, você pode começar a trabalhar apenas usando web.xml e struts.xmlarquivos de configuração (como você já testemunhou em nosso capítulo anterior, onde nosso exemplo trabalhou usando esses dois arquivos). No entanto, para seu conhecimento, explicaremos em relação a outros arquivos também.
O arquivo web.xml
O arquivo de configuração web.xml é um arquivo de configuração J2EE que determina como os elementos da solicitação HTTP são processados pelo contêiner de servlet. Não é estritamente um arquivo de configuração do Struts2, mas é um arquivo que precisa ser configurado para que o Struts2 funcione.
Conforme discutido anteriormente, este arquivo fornece um ponto de entrada para qualquer aplicativo da web. O ponto de entrada do aplicativo Struts2 será um filtro definido no descritor de implantação (web.xml). Portanto, definiremos uma entrada da classe FilterDispatcher em web.xml. O arquivo web.xml precisa ser criado na pastaWebContent/WEB-INF.
Este é o primeiro arquivo de configuração que você precisará configurar se estiver iniciando sem o auxílio de um modelo ou ferramenta que o gera (como Eclipse ou Maven2).
A seguir está o conteúdo do arquivo web.xml que usamos em nosso último exemplo.
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Observe que mapeamos o filtro Struts 2 para /*, e não para /*.actiono que significa que todos os urls serão analisados pelo filtro struts. Abordaremos isso quando passarmos pelo capítulo Anotações.
O arquivo Struts.xml
o struts.xmlO arquivo contém as informações de configuração que você modificará à medida que as ações forem desenvolvidas. Este arquivo pode ser usado para substituir as configurações padrão 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 pastaWEB-INF/classes.
Vamos dar uma olhada no arquivo struts.xml que criamos no exemplo Hello World explicado no capítulo anterior.
<?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.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 DOCTYPE. Todos os arquivos de configuração do struts precisam ter o doctype correto, conforme mostrado em nosso pequeno exemplo. <struts> é o elemento de tag raiz, sob o qual declaramos diferentes pacotes usando tags <package>. Aqui, <package> permite a separação e modularização da configuração. Isso é muito útil quando você tem um grande projeto e o projeto é dividido em diferentes módulos.
Por exemplo, se o seu projeto tiver três domínios - business_application, customer_application e staff_application, você poderá criar três pacotes e armazenar ações associadas no pacote apropriado.
A tag do pacote possui os seguintes atributos -
| Sr. Não | Atributo e descrição |
|---|---|
| 1 | name (required) O identificador único do pacote |
| 2 | extends De qual pacote este pacote se estende? Por padrão, usamos struts-default como pacote base. |
| 3 | abstract Se marcado como verdadeiro, o pacote não está disponível para consumo do usuário final. |
| 4 | namespace Namespace exclusivo para as ações |
o constant tag junto com os atributos de nome e valor devem ser usados para substituir qualquer uma das seguintes propriedades definidas em default.properties, como acabamos de definir struts.devModepropriedade. Configuraçãostruts.devMode propriedade nos permite ver mais mensagens de depuração no arquivo de log.
Nós definimos action tags correspondem a cada URL que desejamos acessar e definimos uma classe com o método execute () que será acessada sempre que acessarmos a URL correspondente.
Os resultados determinam o que é retornado ao navegador depois que uma ação é executada. A string retornada da ação deve ser o nome de um resultado. Os resultados são configurados por ação conforme acima, ou como um resultado "global", disponível para cada ação em um pacote. Os resultados são opcionaisname e typeatributos. O valor do nome padrão é "sucesso".
O arquivo Struts.xml pode crescer muito com o tempo e, portanto, dividi-lo por pacotes é uma forma de modularizá-lo, mas Strutsoferece outra maneira de modularizar o arquivo struts.xml. Você pode dividir o arquivo em vários arquivos xml e importá-los da seguinte maneira.
<?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>
<include file="my-struts1.xml"/>
<include file="my-struts2.xml"/>
</struts>O outro arquivo de configuração que não abordamos é o struts-default.xml. Este arquivo contém as definições de configuração padrão para Struts e você não teria que alterar essas configurações para 99,99% de seus projetos. Por esse motivo, não entraremos em muitos detalhes neste arquivo. Se você estiver interessado, dê uma olhada nodefault.properties arquivo disponível no arquivo struts2-core-2.2.3.jar.
O arquivo Struts-config.xml
O arquivo de configuração struts-config.xml é um link entre os componentes View e Model no Web Client, mas você não teria que alterar essas configurações para 99,99% de seus projetos.
O arquivo de configuração contém basicamente os seguintes elementos principais -
| Sr. Não | Interceptor e descrição |
|---|---|
| 1 | struts-config Este é o nó raiz do arquivo de configuração. |
| 2 | form-beans É aqui que você mapeia sua subclasse ActionForm para um nome. Você usa esse nome como um alias para seu ActionForm em todo o restante do arquivo strutsconfig.xml e até mesmo em suas páginas JSP. |
| 3 | global forwards Esta seção mapeia uma página em seu webapp para um nome. Você pode usar este nome para se referir à página real. Isso evita a codificação de URLs em suas páginas da web. |
| 4 | action-mappings É aqui que você declara os manipuladores de formulário e eles também são conhecidos como mapeamentos de ação. |
| 5 | controller Esta seção configura os componentes internos do Struts e raramente é usado em situações práticas. |
| 6 | plug-in Esta seção informa ao Struts onde encontrar seus arquivos de propriedades, que contêm prompts e mensagens de erro |
A seguir está o arquivo struts-config.xml de amostra -
<?xml version = "1.0" Encoding = "ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
<struts-config>
<!-- ========== Form Bean Definitions ============ -->
<form-beans>
<form-bean name = "login" type = "test.struts.LoginForm" />
</form-beans>
<!-- ========== Global Forward Definitions ========= -->
<global-forwards>
</global-forwards>
<!-- ========== Action Mapping Definitions ======== -->
<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 Definitions ======== -->
<controller contentType = "text/html;charset = UTF-8"
debug = "3" maxFileSize = "1.618M" locale = "true" nocache = "true"/>
</struts-config>Para obter mais detalhes sobre o arquivo struts-config.xml, verifique a documentação do struts.
O arquivo Struts.properties
Este arquivo de configuração fornece um mecanismo para alterar o comportamento padrão da estrutura. Na verdade, todas as propriedades contidas nostruts.properties arquivo de configuração também pode ser configurado no web.xml usando o init-param, além de usar a tag constante no struts.xmlarquivo de configuração. Mas, se você gosta de manter as coisas separadas e mais específicas, você pode criar este arquivo na pastaWEB-INF/classes.
Os valores configurados neste arquivo substituirão os valores padrão configurados em default.propertiesque está contido na distribuição struts2-core-xyzjar. Existem algumas propriedades que você pode considerar alterar usando ostruts.properties arquivo -
### When set to true, Struts will act much more friendly for developers
struts.devMode = true
### Enables reloading of internationalization files
struts.i18n.reload = true
### Enables reloading of XML configuration files
struts.configuration.xml.reload = true
### Sets the port that the server is run on
struts.url.http.port = 8080Aqui, qualquer linha começando com hash (#) será considerado um comentário e será ignorado por Struts 2.
Actionssão o núcleo da estrutura Struts2, como são para qualquer estrutura MVC (Model View Controller). Cada URL é mapeado para uma ação específica, que fornece a lógica de processamento necessária para atender à solicitação do usuário.
Mas a ação também serve em duas outras funções importantes. Em primeiro lugar, a ação desempenha um papel importante na transferência de dados da solicitação para a exibição, seja um JSP ou outro tipo de resultado. Em segundo lugar, a ação deve ajudar a estrutura a determinar qual resultado deve render a visão que será retornada na resposta à solicitação.
Criar ação
O único requisito para ações em Struts2é que deve haver um método sem argumento que retorna um objeto String ou Result e deve ser um POJO. Se o método sem argumento não for especificado, o comportamento padrão é usar o método execute ().
Opcionalmente, você pode estender o ActionSupport classe que implementa seis interfaces, incluindo Actioninterface. A interface de ação é a seguinte -
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 no exemplo Hello World -
package com.tutorialspoint.struts2;
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 em que o método de ação controla a visualização, vamos fazer a seguinte alteração no execute método e estenda a classe ActionSupport da seguinte maneira -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
if ("SECRET".equals(name)) {
return SUCCESS;
} else {
return ERROR;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Neste exemplo, temos alguma lógica no método execute para examinar o atributo name. Se o atributo for igual à string"SECRET", nós voltamos SUCCESS como resultado, caso contrário, retornamos ERRORcomo resultado. Porque estendemos ActionSupport, então podemos usar constantes StringSUCCESSe ERROR. Agora, vamos modificar nosso arquivo struts.xml da seguinte maneira -
<?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.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>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Criar uma vista
Vamos criar o arquivo jsp abaixo HelloWorld.jspna pasta WebContent em seu projeto eclipse. Para fazer isso, clique com o botão direito na pasta WebContent no explorador de projetos e selecioneNew >JSP File. Este arquivo será chamado caso o resultado de retorno seja SUCCESS, que é uma constante String "sucesso" conforme definido na interface Action -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>A seguir está o arquivo que será chamado pelo framework caso o resultado da ação seja ERROR, que é igual à constante String "error". A seguir está o conteúdo deAccessDenied.jsp
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Access Denied</title>
</head>
<body>
You are not authorized to view this page.
</body>
</html>Também precisamos criar index.jspna pasta WebContent. Este arquivo servirá como a URL de ação inicial onde o usuário pode clicar para dizer ao framework do Struts 2 para chamar oexecuteda classe HelloWorldAction e renderizar a visualizaçã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 From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>É isso, não há nenhuma mudança necessária para o arquivo web.xml, então vamos usar o mesmo web.xml que criamos em Examplescapítulo. Agora, estamos prontos para executar nossoHello World aplicativo usando o framework Struts 2.
Execute o aplicativo
Clique com o botão direito no nome do projeto e clique Export > WARArquivo para criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso lhe dará a seguinte tela -
Deixe-nos inserir uma palavra como "SEGREDO" e você verá a seguinte página -
Agora digite qualquer palavra diferente de "SEGREDO" e você verá a seguinte página -
Crie várias ações
Freqüentemente, você definirá mais de uma ação para lidar com diferentes solicitações e fornecer diferentes URLs aos usuários; portanto, você definirá diferentes classes conforme definido abaixo -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
class MyAction extends ActionSupport {
public static String GOOD = SUCCESS;
public static String BAD = ERROR;
}
public class HelloWorld extends ActionSupport {
...
public String execute() {
if ("SECRET".equals(name)) return MyAction.GOOD;
return MyAction.BAD;
}
...
}
public class SomeOtherClass extends ActionSupport {
...
public String execute() {
return MyAction.GOOD;
}
...
}Você vai configurar essas ações no arquivo struts.xml da seguinte forma -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorld"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
<action name = "something"
class = "com.tutorialspoint.struts2.SomeOtherClass"
method = "execute">
<result name = "success">/Something.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Como você pode ver no exemplo hipotético acima, os resultados da ação SUCCESS e ERROR’s são duplicados.
Para contornar esse problema, sugere-se que você crie uma classe que contenha os resultados dos resultados.
Os interceptores são conceitualmente iguais aos filtros de servlet ou à classe JDKs Proxy. Os interceptores permitem que a funcionalidade de crosscutting seja implementada separadamente da ação, bem como da estrutura. Você pode conseguir o seguinte usando interceptores -
Fornecer lógica de pré-processamento antes que a ação seja chamada.
Fornecer lógica de pós-processamento após a ação ser chamada.
Captura de exceções para que o processamento alternativo possa ser executado.
Muitos dos recursos fornecidos no Struts2 framework são implementados usando interceptores;
Examples incluem manipulação de exceção, upload de arquivo, callbacks de ciclo de vida, etc. Na verdade, como Struts2 enfatiza muito de sua funcionalidade em interceptores, não é provável que tenha 7 ou 8 interceptores atribuídos por ação.
Struts2 Framework Interceptors
O framework Struts 2 fornece uma boa lista de interceptores prontos para uso que vêm pré-configurados e prontos para uso. Alguns dos interceptores importantes estão listados abaixo -
| Sr. Não | Interceptor e descrição |
|---|---|
| 1 | alias Permite que os parâmetros tenham nomes alternativos diferentes nas solicitações. |
| 2 | checkbox Auxilia no gerenciamento de caixas de seleção, adicionando um valor de parâmetro false para caixas de seleção que não estão marcadas. |
| 3 | conversionError Coloca informações de erro de conversão de strings em tipos de parâmetro nos erros de campo da ação. |
| 4 | createSession Cria automaticamente uma sessão HTTP, se ainda não houver uma. |
| 5 | debugging Fornece várias telas de depuração diferentes para o desenvolvedor. |
| 6 | execAndWait Envia o usuário para uma página de espera intermediária enquanto a ação é executada em segundo plano. |
| 7 | exception Mapeia as exceções que são lançadas de uma ação para um resultado, permitindo o tratamento automático de exceções por meio de redirecionamento. |
| 8 | fileUpload Facilita o envio de arquivos fácil. |
| 9 | i18n Mantém o controle do local selecionado durante a sessão de um usuário. |
| 10 | logger Fornece registro simples, exibindo o nome da ação que está sendo executada. |
| 11 | params Define os parâmetros de solicitação na ação. |
| 12 | prepare Isso normalmente é usado para fazer o trabalho de pré-processamento, como configurar conexões de banco de dados. |
| 13 | profile Permite que informações simples de perfil sejam registradas para ações. |
| 14 | scope Armazena e recupera o estado da ação no escopo da sessão ou do aplicativo. |
| 15 | ServletConfig Fornece à ação acesso a várias informações baseadas em servlet. |
| 16 | timer Fornece informações de perfil simples na forma de quanto tempo a ação leva para ser executada. |
| 17 | token Verifica a ação de um token válido para evitar o envio duplicado de formulários. |
| 18 | validation Fornece suporte de validação para ações |
Consulte a documentação do Struts 2 para obter detalhes completos sobre os interceptores mencionados acima. Mas vou mostrar como usar um interceptor em geral em seu aplicativo Struts.
Como usar interceptores?
Vamos ver como usar um interceptor já existente para nosso programa "Hello World". Vamos usar otimerinterceptor cujo objetivo é medir quanto tempo levou para executar um método de ação. Ao mesmo tempo, estou usandoparamsinterceptor cujo objetivo é enviar os parâmetros do pedido para a ação. Você pode tentar o seu exemplo sem usar este interceptor e você vai descobrir quename a propriedade não está sendo definida porque o parâmetro não pode alcançar a ação.
Manteremos os arquivos HelloWorldAction.java, web.xml, HelloWorld.jsp e index.jsp como foram criados em Examples capítulo, mas vamos modificar o struts.xml arquivo para adicionar um interceptor da seguinte forma -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "timer" />
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Agora insira qualquer palavra na caixa de texto fornecida e clique no botão Diga Olá para executar a ação definida. Agora, se você verificar o log gerado, encontrará o seguinte texto -
INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.Aqui, o resultado final está sendo gerado por causa de timer interceptador que está dizendo que a ação levou um total de 109 ms para ser executada.
Crie interceptores personalizados
Usar interceptores customizados em seu aplicativo é uma maneira elegante de fornecer recursos de aplicativo transversais. Criar um interceptor customizado é fácil; a interface que precisa ser estendida é a seguinteInterceptor interface -
public interface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation)
throws Exception;
}Como os nomes sugerem, o método init () fornece uma maneira de inicializar o interceptor, e o método destroy () fornece um recurso para limpeza do interceptor. Ao contrário das ações, os interceptores são reutilizados nas solicitações e precisam ser threadsafe, especialmente o método intercept ().
o ActionInvocationobjeto fornece acesso ao ambiente de tempo de execução. Ele permite o acesso à própria ação e métodos para invocar a ação e determinar se a ação já foi chamada.
Se você não precisa de inicialização ou código de limpeza, o AbstractInterceptorclasse pode ser estendida. Isso fornece uma implementação padrão nooperation dos métodos init () e destroy ().
Criar classe de interceptador
Vamos criar o seguinte MyInterceptor.java em Java Resources > src pasta -
package com.tutorialspoint.struts2;
import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class MyInterceptor extends AbstractInterceptor {
public String intercept(ActionInvocation invocation)throws Exception {
/* let us do some pre-processing */
String output = "Pre-Processing";
System.out.println(output);
/* let us call action or next interceptor */
String result = invocation.invoke();
/* let us do some post-processing */
output = "Post-Processing";
System.out.println(output);
return result;
}
}Como você pode notar, a ação real será executada usando o interceptor por invocation.invoke()ligar. Portanto, você pode fazer algum pré-processamento e pós-processamento com base em seus requisitos.
A própria estrutura inicia o processo fazendo a primeira chamada para invoke () do objeto ActionInvocation. Cada vezinvoke()for chamado, ActionInvocation consulta seu estado e executa qualquer interceptor que vier a seguir. Quando todos os interceptores configurados forem chamados, o método invoke () fará com que a própria ação seja executada.
O diagrama a seguir mostra o mesmo conceito por meio de um fluxo de solicitação -
Criar classe de ação
Vamos criar um arquivo java HelloWorldAction.java em Java Resources > src com um nome de pacote com.tutorialspoint.struts2 com o conteúdo fornecido abaixo.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
System.out.println("Inside action....");
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Esta é a mesma classe que vimos nos exemplos anteriores. Temos métodos getters e setter padrão para a propriedade "name" e um método execute que retorna a string "success".
Criar uma vista
Vamos criar o arquivo jsp abaixo HelloWorld.jsp na pasta WebContent em seu projeto eclipse.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Criar página principal
Também precisamos criar index.jspna pasta WebContent. Esse arquivo servirá como a URL de ação inicial em que um usuário pode clicar para informar a estrutura do Struts 2 para chamar um método definido da classe HelloWorldAction e renderizar a visualizaçã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 From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>o hello a ação definida no arquivo de visualização acima será mapeada para a classe HelloWorldAction e seu método de execução usando o arquivo struts.xml.
Arquivos de configuração
Agora, precisamos registrar nosso interceptor e chamá-lo como tínhamos chamado o interceptor padrão no exemplo anterior. Para registrar um interceptor recém-definido, as tags <interceptors> ... </interceptors> são colocadas diretamente sob as tags <package>.struts.xmlArquivo. Você pode pular esta etapa para interceptores padrão, como fizemos em nosso exemplo anterior. Mas aqui vamos registrar e usá-lo da seguinte maneira -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<interceptors>
<interceptor name = "myinterceptor"
class = "com.tutorialspoint.struts2.MyInterceptor" />
</interceptors>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "myinterceptor" />
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Deve-se notar que você pode registrar mais de um interceptador dentro <package> tag e ao mesmo tempo, você pode chamar mais de um interceptador dentro do <action>tag. Você pode chamar o mesmo interceptor com as diferentes ações.
O arquivo web.xml precisa ser criado na pasta WEB-INF em WebContent da seguinte forma -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Agora insira qualquer palavra na caixa de texto fornecida e clique no botão Diga Olá para executar a ação definida. Agora, se você verificar o log gerado, encontrará o seguinte texto na parte inferior -
Pre-Processing
Inside action....
Post-ProcessingEmpilhando vários interceptores
Como você pode imaginar, ter que configurar vários interceptores para cada ação rapidamente se tornaria extremamente incontrolável. Por esse motivo, os interceptores são gerenciados com pilhas de interceptores. Aqui está um exemplo, diretamente do arquivo strutsdefault.xml -
<interceptor-stack name = "basicStack">
<interceptor-ref name = "exception"/>
<interceptor-ref name = "servlet-config"/>
<interceptor-ref name = "prepare"/>
<interceptor-ref name = "checkbox"/>
<interceptor-ref name = "params"/>
<interceptor-ref name = "conversionError"/>
</interceptor-stack>A aposta acima é chamada basicStacke pode ser usado em sua configuração conforme mostrado abaixo. Este nó de configuração é colocado no nó <pacote ... />. Cada tag <interceptor-ref ... /> faz referência a um interceptor ou a uma pilha de interceptor que foi configurada antes da pilha de interceptor atual. Portanto, é muito importante garantir que o nome seja exclusivo em todas as configurações de pilha de interceptores e interceptores ao configurar os interceptores iniciais e as pilhas de interceptores.
Já vimos como aplicar interceptor à ação, aplicando pilhas de interceptores não é diferente. Na verdade, usamos exatamente a mesma tag -
<action name = "hello" class = "com.tutorialspoint.struts2.MyAction">
<interceptor-ref name = "basicStack"/>
<result>view.jsp</result>
</actionO registro acima de "basicStack" registrará a aposta completa de todos os seis interceptores com ação hello. Deve-se observar que os interceptores são executados na ordem em que foram configurados. Por exemplo, no caso acima, a exceção será executada primeiro, a segunda seria servlet-config e assim por diante.
Como mencionado anteriormente, o <results> tag desempenha o papel de um viewna estrutura MVC do Struts2. A ação é responsável por executar a lógica de negócios. A próxima etapa após executar a lógica de negócios é exibir a visualização usando o<results> tag.
Freqüentemente, há algumas regras de navegação anexadas aos resultados. Por exemplo, se o método de ação é autenticar um usuário, existem três resultados possíveis.
- Login realizado com sucesso
- Login malsucedido - nome de usuário ou senha incorretos
- Conta bloqueada
Neste cenário, o método de ação será configurado com três strings de resultados possíveis e três visualizações diferentes para renderizar o resultado. Já vimos isso nos exemplos anteriores.
Mas o Struts2 não obriga você a usar JSP como tecnologia de visualização. Afinal, todo o propósito do paradigma MVC é manter as camadas separadas e altamente configuráveis. Por exemplo, para um cliente Web2.0, você pode querer retornar XML ou JSON como saída. Nesse caso, você pode criar um novo tipo de resultado para XML ou JSON e conseguir isso.
O Struts vem com uma série de result types e tudo o que já vimos que era o tipo de resultado padrão dispatcher, que é usado para despachar para páginas JSP. Struts permitem que você use outras linguagens de marcação para a tecnologia de visualização para apresentar os resultados e as escolhas populares incluemVelocity, Freemaker, XSLT e Tiles.
O tipo de resultado do despachante
o dispatchertipo de resultado é o tipo padrão e é usado se nenhum outro tipo de resultado for especificado. É usado para encaminhar para um servlet, JSP, página HTML e assim por diante, no servidor. Ele usa o método RequestDispatcher.forward () .
Vimos a versão "abreviada" em nossos exemplos anteriores, em que fornecemos um caminho JSP como o corpo da tag de resultado.
<result name = "success">
/HelloWorld.jsp
</result>Também podemos especificar o arquivo JSP usando uma tag <param name = "location"> dentro do elemento <result ...> da seguinte maneira -
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>Nós também podemos fornecer um parseparâmetro, que é verdadeiro por padrão. O parâmetro de análise determina se o parâmetro de localização será analisado ou não para expressões OGNL.
O tipo de resultado do FreeMaker
Neste exemplo, vamos ver como podemos usar FreeMakercomo a tecnologia de exibição. Freemaker é um mecanismo de modelagem popular que é usado para gerar saída usando modelos predefinidos. Vamos agora criar um arquivo de modelo do Freemaker chamadohello.fm com os seguintes conteúdos -
Hello World ${name}O arquivo acima é um modelo onde nameé um parâmetro que será passado de fora usando a ação definida. Você manterá este arquivo em seu CLASSPATH.
A seguir, vamos modificar o struts.xml para especificar o resultado da seguinte forma -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "freemarker">
<param name = "location">/hello.fm</param>
</result>
</action>
</package>
</struts>Vamos manter nossos arquivos HelloWorldAction.java, HelloWorldAction.jsp e index.jsp como os criamos no capítulo de exemplos.
Agora clique com o botão direito no nome do projeto e clique Export > WAR File para criar um arquivo de guerra.
Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a tela a seguir.
Insira um valor "Struts2" e envie a página. Você deve ver a próxima página.
Como você pode ver, é exatamente igual à visualização JSP, exceto que não estamos vinculados ao uso de JSP como a tecnologia de visualização. Usamos o Freemaker neste exemplo.
O tipo de resultado de redirecionamento
o redirecttipo de resultado chama o método response.sendRedirect () padrão , fazendo com que o navegador crie uma nova solicitação para o local fornecido.
Podemos fornecer a localização no corpo do elemento <result ...> ou como um elemento <param name = "location">. Redirect também suporta oparseparâmetro. Aqui está um exemplo configurado usando XML -
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>Portanto, apenas modifique seu arquivo struts.xml para definir o tipo de redirecionamento como mencionado acima e crie um novo arquivo NewWorld.jpg onde você será redirecionado sempre que a ação hello retornar com sucesso. Você pode verificar o exemplo de Ação de redirecionamento do Struts 2 para melhor compreensão.
The Value Stack
A pilha de valores é um conjunto de vários objetos que mantém os seguintes objetos na ordem fornecida -
| Sr. Não | Objetos e descrição |
|---|---|
| 1 | Temporary Objects Existem vários objetos temporários que são criados durante a execução de uma página. Por exemplo, o valor de iteração atual para uma coleção que está sendo repetida em uma tag JSP. |
| 2 | The Model Object Se você estiver usando objetos de modelo em seu aplicativo struts, o objeto de modelo atual é colocado antes da ação na pilha de valores. |
| 3 | The Action Object Este será o objeto de ação atual que está sendo executado. |
| 4 | Named Objects Esses objetos incluem #application, #session, #request, #attr e #parameters e se referem aos escopos de servlet correspondentes. |
A pilha de valores pode ser acessada por meio das tags fornecidas para JSP, Velocity ou Freemarker. Existem várias tags que estudaremos em capítulos separados, são usadas para obter e definir a pilha de valores do struts 2.0. Você pode obter o objeto valueStack dentro de sua ação da seguinte maneira -
ActionContext.getContext().getValueStack()Depois de ter um objeto ValueStack, você pode usar os seguintes métodos para manipular esse objeto -
| Sr. Não | Métodos e descrição de ValueStack |
|---|---|
| 1 | Object findValue(String expr) Encontre um valor avaliando a expressão fornecida em relação à pilha na ordem de pesquisa padrão. |
| 2 | CompoundRoot getRoot() Obtenha o CompoundRoot que mantém os objetos colocados na pilha. |
| 3 | Object peek() Coloque o objeto no topo da pilha sem alterar a pilha. |
| 4 | Object pop() Pegue o objeto no topo da pilha e remova-o da pilha. |
| 5 | void push(Object o) Coloque este objeto no topo da pilha. |
| 6 | void set(String key, Object o) Define um objeto na pilha com a chave fornecida para que seja recuperável por findValue (chave, ...) |
| 7 | void setDefaultType(Class defaultType) Define o tipo padrão para conversão se nenhum tipo for fornecido ao obter um valor. |
| 8 | void setValue(String expr, Object value) Tenta definir uma propriedade em um bean na pilha com a expressão fornecida usando a ordem de pesquisa padrão. |
| 9 | int size() Obtenha o número de objetos na pilha. |
OGNL
o Object-Graph Navigation Language(OGNL) é uma linguagem de expressão poderosa usada para fazer referência e manipular dados no ValueStack. OGNL também ajuda na transferência de dados e conversão de tipo.
O OGNL é muito semelhante ao JSP Expression Language. OGNL é baseado na ideia de ter uma raiz ou objeto padrão dentro do contexto. As propriedades do objeto padrão ou raiz podem ser referenciadas usando a notação de marcação, que é o símbolo de libra.
Conforme mencionado anteriormente, OGNL é baseado em um contexto e Struts constrói um mapa ActionContext para uso com OGNL. O mapa ActionContext consiste no seguinte -
Application - Variáveis com escopo de aplicativo
Session - Variáveis com escopo de sessão
Root / value stack - Todas as suas variáveis de ação são armazenadas aqui
Request - Solicitar variáveis com escopo
Parameters - Parâmetros de solicitação
Atributes - Os atributos armazenados na página, solicitação, sessão e escopo do aplicativo
É importante entender que o objeto Action está sempre disponível na pilha de valores. Portanto, se o seu objeto Action tem propriedades“x” e “y” lá estão disponíveis para você usar.
Os objetos no ActionContext são referenciados usando o símbolo de libra, no entanto, os objetos na pilha de valores podem ser referenciados diretamente.
Por exemplo, se employee é uma propriedade de uma classe de ação, então ela pode ser referenciada da seguinte maneira -
<s:property value = "name"/>ao invés de
<s:property value = "#name"/>Se você tiver um atributo na sessão chamado "login", você pode recuperá-lo da seguinte maneira -
<s:property value = "#session.login"/>OGNL também suporta lidar com coleções - a saber, Mapa, Lista e Conjunto. Por exemplo, para exibir uma lista suspensa de cores, você pode fazer -
<s:select name = "color" list = "{'red','yellow','green'}" />A expressão OGNL é inteligente para interpretar o "vermelho", "amarelo", "verde" como cores e construir uma lista com base nisso.
As expressões OGNL serão usadas extensivamente nos próximos capítulos, quando estudaremos diferentes tags. Portanto, em vez de examiná-los isoladamente, vamos examiná-los usando alguns exemplos na seção Tags de formulário / Tags de controle / Tags de dados e tags Ajax.
Exemplo ValueStack / OGNL
Criar ação
Vamos considerar a seguinte classe de ação onde estamos acessando valueStack e então definindo algumas chaves que iremos acessar usando OGNL em nossa visão, isto é, página JSP.
package com.tutorialspoint.struts2;
import java.util.*;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
Map<String, Object> context = new HashMap<String, Object>();
context.put("key1", new String("This is key1"));
context.put("key2", new String("This is key2"));
stack.push(context);
System.out.println("Size of the valueStack: " + stack.size());
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Na verdade, o Struts 2 adiciona sua ação ao topo do valueStack quando executado. Portanto, a maneira usual de colocar coisas na pilha de valores é adicionar getters / setters para os valores à sua classe Action e, em seguida, usar a tag <s: property> para acessar os valores. Mas estou mostrando como exatamente ActionContext e ValueStack funcionam em struts.
Criar Vistas
Vamos criar o arquivo jsp abaixo HelloWorld.jspna pasta WebContent em seu projeto eclipse. Esta visualização será exibida caso a ação retorne com sucesso -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Entered value : <s:property value = "name"/><br/>
Value of key 1 : <s:property value = "key1" /><br/>
Value of key 2 : <s:property value = "key2" /> <br/>
</body>
</html>Também precisamos criar index.jsp na pasta WebContent cujo conteúdo é o seguinte -
<%@ 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 From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>Arquivos de configuração
A seguir está o conteúdo de struts.xml arquivo -
<?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.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>
</package>
</struts>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat.
Finalmente, inicie o servidor Tomcat e tente acessar o URL http://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela
Agora insira qualquer palavra na caixa de texto fornecida e clique no botão "Diga Olá" para executar a ação definida. Agora, se você verificar o log gerado, encontrará o seguinte texto na parte inferior -
Size of the valueStack: 3Isso exibirá a tela a seguir, que exibirá qualquer valor que você inserir e o valor de key1 e key2 que colocamos no ValueStack.
A estrutura do Struts 2 fornece suporte integrado para processamento de upload de arquivo usando "Upload de arquivo baseado em formulário em HTML". Quando um arquivo é carregado, ele normalmente é armazenado em um diretório temporário e deve ser processado ou movido por sua classe Action para um diretório permanente para garantir que os dados não sejam perdidos.
Note - Os servidores podem ter uma política de segurança em vigor que o proíbe de gravar em diretórios que não sejam o diretório temporário e os diretórios que pertencem ao seu aplicativo da web.
O upload de arquivos no Struts é possível através de um interceptor pré-definido chamado FileUpload interceptor que está disponível por meio da classe org.apache.struts2.interceptor.FileUploadInterceptor e incluído como parte dodefaultStack. Ainda assim, você pode usar isso em seu struts.xml para definir vários parâmetros, como veremos a seguir.
Criar arquivos de visualização
Vamos começar criando nossa visão que será necessária para navegar e carregar um arquivo selecionado. Então, vamos criar umindex.jsp com formulário de upload de HTML simples que permite ao usuário fazer upload de um arquivo -
<%@ 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>File Upload</title>
</head>
<body>
<form action = "upload" method = "post" enctype = "multipart/form-data">
<label for = "myFile">Upload your file</label>
<input type = "file" name = "myFile" />
<input type = "submit" value = "Upload"/>
</form>
</body>
</html>Há alguns pontos dignos de nota no exemplo acima. Primeiro, o enctype do formulário é definido comomultipart/form-data. Isso deve ser definido para que os uploads de arquivos sejam tratados com êxito pelo interceptor de upload de arquivos. O próximo ponto a ser observado é o método de ação do formulárioupload e o nome do campo de upload de arquivo - que é myFile. Precisamos dessas informações para criar o método de ação e a configuração do struts.
A seguir, vamos criar um arquivo jsp simples success.jsp para exibir o resultado do nosso upload de arquivo, caso seja um sucesso.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Success</title>
</head>
<body>
You have successfully uploaded <s:property value = "myFileFileName"/>
</body>
</html>A seguir estará o arquivo de resultado error.jsp caso haja algum erro no upload do arquivo -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Error</title>
</head>
<body>
There has been an error in uploading the file.
</body>
</html>Criar classe de ação
A seguir, vamos criar uma classe Java chamada uploadFile.java que cuidará de enviar o arquivo e armazená-lo em um local seguro -
package com.tutorialspoint.struts2;
import java.io.File;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
import com.opensymphony.xwork2.ActionSupport;
public class uploadFile extends ActionSupport {
private File myFile;
private String myFileContentType;
private String myFileFileName;
private String destPath;
public String execute() {
/* Copy file to a safe location */
destPath = "C:/apache-tomcat-6.0.33/work/";
try {
System.out.println("Src File name: " + myFile);
System.out.println("Dst File name: " + myFileFileName);
File destFile = new File(destPath, myFileFileName);
FileUtils.copyFile(myFile, destFile);
} catch(IOException e) {
e.printStackTrace();
return ERROR;
}
return SUCCESS;
}
public File getMyFile() {
return myFile;
}
public void setMyFile(File myFile) {
this.myFile = myFile;
}
public String getMyFileContentType() {
return myFileContentType;
}
public void setMyFileContentType(String myFileContentType) {
this.myFileContentType = myFileContentType;
}
public String getMyFileFileName() {
return myFileFileName;
}
public void setMyFileFileName(String myFileFileName) {
this.myFileFileName = myFileFileName;
}
}o uploadFile.javaé uma aula muito simples. O importante a notar é que o interceptor FileUpload, juntamente com o Parameters Interceptor, faz todo o trabalho pesado para nós.
O interceptor FileUpload disponibiliza três parâmetros para você por padrão. Eles são nomeados no seguinte padrão -
[your file name parameter] - Este é o arquivo real que o usuário carregou. Neste exemplo, será "myFile"
[your file name parameter]ContentType- Este é o tipo de conteúdo do arquivo que foi carregado. Neste exemplo, será "myFileContentType"
[your file name parameter]FileName- Este é o nome do arquivo que foi carregado. Neste exemplo, será "myFileFileName"
Os três parâmetros estão disponíveis para nós, graças aos Struts Interceptors. Tudo o que precisamos fazer é criar três parâmetros com os nomes corretos em nossa classe Action e automaticamente essas variáveis são conectadas automaticamente para nós. Portanto, no exemplo acima, temos três parâmetros e um método de ação que simplesmente retorna "sucesso" se tudo correr bem, caso contrário, retorna "erro".
Arquivos de configuração
A seguir estão as propriedades de configuração do Struts2 que controlam o processo de upload de arquivos -
| Sr. Não | Propriedades e descrição |
|---|---|
| 1 | struts.multipart.maxSize O tamanho máximo (em bytes) de um arquivo a ser aceito como upload de arquivo. O padrão é 250M. |
| 2 | struts.multipart.parser A biblioteca usada para fazer upload do formulário de várias partes. Por padrão éjakarta |
| 3 | struts.multipart.saveDir O local para armazenar o arquivo temporário. Por padrão, é javax.servlet.context.tempdir. |
Para alterar qualquer uma dessas configurações, você pode usar constant tag no arquivo struts.xml de seus aplicativos, como fiz para alterar o tamanho máximo de um arquivo a ser carregado.
Deixe-nos ter nosso struts.xml como segue -
<?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.devMode" value = "true" />
<constant name = "struts.multipart.maxSize" value = "1000000" />
<package name = "helloworld" extends = "struts-default">
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Desde a, FileUploadinterceptor é uma parte da pilha de interceptores padrão, não precisamos configurá-lo explicitamente. Mas, você pode adicionar a tag <interceptor-ref> dentro de <action>. O interceptor fileUpload leva dois parâmetros(a) maximumSize e (b) allowedTypes.
O parâmetro maximumSize define o tamanho máximo de arquivo permitido (o padrão é aproximadamente 2 MB). O parâmetro allowedTypes é uma lista separada por vírgulas de tipos de conteúdo aceito (MIME), conforme mostrado abaixo -
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<interceptor-ref name = "basicStack">
<interceptor-ref name = "fileUpload">
<param name = "allowedTypes">image/jpeg,image/gif</param>
</interceptor-ref>
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/upload.jsp. Isso produzirá a seguinte tela -
Agora selecione um arquivo "Contacts.txt" usando o botão Browse e clique no botão upload que fará o upload do arquivo em seu servidor e você verá a próxima página. Você pode verificar se o arquivo carregado deve ser salvo em C: \ apache-tomcat-6.0.33 \ work.
Observe que o FileUpload Interceptor exclui o arquivo carregado automaticamente, então você terá que salvar o arquivo carregado programaticamente em algum local antes de ser excluído.
Mensagens de erro
O interceptor fileUplaod usa várias chaves de mensagem de erro padrão -
| Sr. Não | Chave e descrição da mensagem de erro |
|---|---|
| 1 | struts.messages.error.uploading Um erro geral que ocorre quando o arquivo não pode ser carregado. |
| 2 | struts.messages.error.file.too.large Ocorre quando o arquivo carregado é muito grande, conforme especificado por maximumSize. |
| 3 | struts.messages.error.content.type.not.allowed Ocorre quando o arquivo carregado não corresponde aos tipos de conteúdo especificados especificados. |
Você pode substituir o texto dessas mensagens em WebContent/WEB-INF/classes/messages.properties arquivos de recursos.
Este capítulo irá ensiná-lo a acessar um banco de dados usando o Struts 2 em etapas simples. Struts é uma estrutura MVC e não uma estrutura de banco de dados, mas fornece excelente suporte para integração JPA / Hibernate. Veremos a integração do hibernate em um capítulo posterior, mas neste capítulo usaremos o JDBC antigo e simples para acessar o banco de dados.
O primeiro passo neste capítulo é configurar e preparar nosso banco de dados. Estou usando o MySQL como meu banco de dados para este exemplo. Tenho o MySQL instalado em minha máquina e criei um novo banco de dados chamado "struts_tutorial". Eu criei uma mesa chamadalogine o preencheu com alguns valores. Abaixo está o script que usei para criar e preencher a tabela.
Meu banco de dados MYSQL tem o nome de usuário padrão "root" e a senha "root123"
CREATE TABLE `struts_tutorial`.`login` (
`user` VARCHAR( 10 ) NOT NULL ,
`password` VARCHAR( 10 ) NOT NULL ,
`name` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `user` )
) ENGINE = InnoDB;
INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');A próxima etapa é baixar o arquivo jar do MySQL Connector e colocá-lo na pasta WEB-INF \ lib do seu projeto. Depois de fazer isso, agora estamos prontos para criar a classe de ação.
Criar ação
A classe de ação possui as propriedades correspondentes às colunas na tabela do banco de dados. Nós temosuser, password e namecomo atributos de String. No método de ação, utilizamos os parâmetros usuário e senha para verificar se o usuário existe, em caso afirmativo, exibimos o nome do usuário na próxima tela.
Se o usuário inseriu informações erradas, nós o enviamos para a tela de login novamente.
A seguir está o conteúdo de LoginAction.java arquivo -
package com.tutorialspoint.struts2;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String user;
private String password;
private String name;
public String execute() {
String ret = ERROR;
Connection conn = null;
try {
String URL = "jdbc:mysql://localhost/struts_tutorial";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, "root", "root123");
String sql = "SELECT name FROM login WHERE";
sql+=" user = ? AND password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, user);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
name = rs.getString(1);
ret = SUCCESS;
}
} catch (Exception e) {
ret = ERROR;
} finally {
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
}
}
}
return ret;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Criar página principal
Agora, vamos criar um arquivo JSP index.jsppara coletar o nome de usuário e a senha. Este nome de usuário e senha serão verificados no banco de dados.
<%@ 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>Login</title>
</head>
<body>
<form action = "loginaction" method = "post">
User:<br/><input type = "text" name = "user"/><br/>
Password:<br/><input type = "password" name = "password"/><br/>
<input type = "submit" value = "Login"/>
</form>
</body>
</html>Criar Vistas
Agora vamos criar success.jsp que será invocado caso a ação retorne SUCCESS, mas teremos outro arquivo de visão caso um ERROR seja retornado da ação.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Successful Login</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>A seguir estará o arquivo de visualização error.jsp no caso de um ERROR ser retornado da ação.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Invalid User Name or Password</title>
</head>
<body>
Wrong user name or password provided.
</body>
</html>Arquivos de configuração
Finalmente, vamos colocar tudo junto usando o arquivo de configuração struts.xml da seguinte maneira -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "loginaction"
class = "com.tutorialspoint.struts2.LoginAction"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Insira um nome de usuário e senha incorretos. Você deve ver a próxima página.
Agora entre scott como nome de usuário e navycomo senha. Você deve ver a próxima página.
Este capítulo explica como você pode enviar um e-mail usando o aplicativo Struts 2.
Para este exercício, você precisa baixar e instalar o mail.jar da API JavaMail 1.4.4 e colocar omail.jar em sua pasta WEB-INF \ lib e, a seguir, siga as etapas padrão de criação de arquivos de ação, visualização e configuração.
Criar ação
A próxima etapa é criar um método Action que se encarregue de enviar o e-mail. Vamos criar uma nova classe chamadaEmailer.java com os seguintes conteúdos.
package com.tutorialspoint.struts2;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import com.opensymphony.xwork2.ActionSupport;
public class Emailer extends ActionSupport {
private String from;
private String password;
private String to;
private String subject;
private String body;
static Properties properties = new Properties();
static {
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
}
public String execute() {
String ret = SUCCESS;
try {
Session session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication
getPasswordAuthentication() {
return new
PasswordAuthentication(from, password);
}
}
);
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
message.setSubject(subject);
message.setText(body);
Transport.send(message);
} catch(Exception e) {
ret = ERROR;
e.printStackTrace();
}
return ret;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public static Properties getProperties() {
return properties;
}
public static void setProperties(Properties properties) {
Emailer.properties = properties;
}
}Como visto no código-fonte acima, o Emailer.javapossui propriedades que correspondem aos atributos de formulário na página email.jsp fornecida abaixo. Esses atributos são -
From- O endereço de e-mail do remetente. Como estamos usando o SMTP do Google, precisamos de um id gtalk válido
Password - A senha da conta acima
To - Para quem enviar o e-mail?
Subject - assunto do email
Body - A mensagem de e-mail real
Não consideramos quaisquer validações nos campos acima, as validações serão adicionadas no próximo capítulo. Vejamos agora o método execute (). O método execute () usa a biblioteca javax Mail para enviar um e-mail usando os parâmetros fornecidos. Se o e-mail for enviado com sucesso, a ação retorna SUCCESS, caso contrário, retorna ERROR.
Criar página principal
Vamos escrever o arquivo JSP da página principal index.jsp, que será usado para coletar informações relacionadas ao e-mail mencionadas acima -
<%@ 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>Email Form</title>
</head>
<body>
<em>The form below uses Google's SMTP server.
So you need to enter a gmail username and password
</em>
<form action = "emailer" method = "post">
<label for = "from">From</label><br/>
<input type = "text" name = "from"/><br/>
<label for = "password">Password</label><br/>
<input type = "password" name = "password"/><br/>
<label for = "to">To</label><br/>
<input type = "text" name = "to"/><br/>
<label for = "subject">Subject</label><br/>
<input type = "text" name = "subject"/><br/>
<label for = "body">Body</label><br/>
<input type = "text" name = "body"/><br/>
<input type = "submit" value = "Send Email"/>
</form>
</body>
</html>Criar Vistas
Usaremos arquivo JSP success.jsp que será invocado caso a ação retorne SUCCESS, mas teremos outro arquivo de visualização caso um ERROR seja retornado da ação.
<%@ 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>Email Success</title>
</head>
<body>
Your email to <s:property value = "to"/> was sent successfully.
</body>
</html>A seguir estará o arquivo de visualização error.jsp no caso de um ERROR ser retornado da ação.
<%@ 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>Email Error</title>
</head>
<body>
There is a problem sending your email to <s:property value = "to"/>.
</body>
</html>Arquivos de configuração
Agora vamos colocar tudo junto usando o arquivo de configuração struts.xml da seguinte maneira -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "emailer"
class = "com.tutorialspoint.struts2.Emailer"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Insira as informações necessárias e clique em Send Emailbotão. Se tudo correr bem, você deverá ver a página seguinte.
Neste capítulo, examinaremos mais profundamente a estrutura de validação do Struts. No núcleo do Struts, temos a estrutura de validação que auxilia o aplicativo a executar as regras para realizar a validação antes que o método de ação seja executado.
A validação do lado do cliente geralmente é obtida usando Javascript. No entanto, não se deve confiar apenas na validação do lado do cliente. As melhores práticas sugerem que a validação deve ser introduzida em todos os níveis de sua estrutura de aplicativo. Agora, vamos examinar duas maneiras de adicionar validação ao nosso projeto Struts.
Aqui, vamos dar um exemplo de um Employee cujo nome e idade devem ser capturados usando uma página simples, e colocaremos essas duas validações para garantir que o usuário sempre insira um nome e idade que deve estar em um intervalo entre 28 e 65.
Vamos começar com a página JSP principal do exemplo.
Criar página principal
Vamos escrever o arquivo JSP da página principal index.jsp, que será usado para coletar as informações relacionadas aos Funcionários mencionadas acima.
<%@ 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>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>O index.jsp faz uso da tag Struts, que ainda não cobrimos, mas vamos estudá-los em capítulos relacionados a tags. Mas, por enquanto, apenas suponha que a tag s: textfield imprime um campo de entrada e s: submit imprime um botão de envio. Usamos a propriedade label para cada tag, que cria um rótulo para cada tag.
Criar Vistas
Usaremos o arquivo JSP success.jsp que será invocado caso a ação definida retorne SUCCESS.
<%@ 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>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Criar ação
Então, vamos definir uma pequena classe de ação Employeee, em seguida, adicione um método chamado validate() como mostrado abaixo em Employee.javaArquivo. Certifique-se de que sua classe de ação estende oActionSupport classe, caso contrário, seu método de validação não será executado.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport {
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void validate() {
if (name == null || name.trim().equals("")) {
addFieldError("name","The name is required");
}
if (age < 28 || age > 65) {
addFieldError("age","Age must be in between 28 and 65");
}
}
}Conforme mostrado no exemplo acima, o método de validação verifica se o campo 'Nome' tem um valor ou não. Se nenhum valor for fornecido, adicionamos um erro de campo para o campo 'Nome' com uma mensagem de erro personalizada. Em segundo lugar, verificamos se o valor inserido para o campo 'Idade' está entre 28 e 65 ou não, caso esta condição não se cumpra adicionamos um erro acima do campo validado.
Arquivos de configuração
Finalmente, vamos colocar tudo junto usando o struts.xml arquivo de configuração da seguinte forma -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
</package>
</struts>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Agora não insira nenhuma informação necessária, basta clicar em Submitbotão. Você verá o seguinte resultado -
Insira as informações necessárias, mas insira um campo De errado, digamos que o nome seja "teste" e a idade 30 e, por fim, clique em Submitbotão. Você verá o seguinte resultado -
Como funciona essa validação?
Quando o usuário pressiona o botão enviar, o Struts 2 executará automaticamente o método de validação e se algum dos “if”as declarações listadas dentro do método são verdadeiras, o Struts 2 chamará seu método addFieldError. Se algum erro tiver sido adicionado, o Struts 2 não continuará a chamar o método execute. Em vez disso, a estrutura do Struts 2 retornaráinput como resultado de chamar a ação.
Portanto, quando a validação falha e o Struts 2 retorna input, a estrutura do Struts 2 exibirá novamente o arquivo index.jsp. Como usamos tags de formulário do Struts 2, o Struts 2 adicionará automaticamente as mensagens de erro logo acima do formulário preenchido.
Essas mensagens de erro são as que especificamos na chamada do método addFieldError. O método addFieldError leva dois argumentos. O primeiro, é oform nome do campo ao qual o erro se aplica e o segundo, é a mensagem de erro a ser exibida acima desse campo de formulário.
addFieldError("name","The name is required");Para lidar com o valor de retorno de input precisamos adicionar o seguinte resultado ao nosso nó de ação em struts.xml.
<result name = "input">/index.jsp</result>Validação baseada em XML
O segundo método de fazer a validação é colocar um arquivo xml próximo à classe de ação. A validação baseada em XML Struts2 oferece mais opções de validação como validação de e-mail, validação de intervalo inteiro, campo de validação de formulário, validação de expressão, validação de regex, validação necessária, validação de string necessária, validação de comprimento de string e etc.
O arquivo xml precisa ser nomeado '[action-class]'-validation.xml. Então, no nosso caso, criamos um arquivo chamadoEmployee-validation.xml com os seguintes conteúdos -
<!DOCTYPE validators PUBLIC
"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name = "name">
<field-validator type = "required">
<message>
The name is required.
</message>
</field-validator>
</field>
<field name = "age">
<field-validator type = "int">
<param name = "min">29</param>
<param name = "max">64</param>
<message>
Age must be in between 28 and 65
</message>
</field-validator>
</field>
</validators>O arquivo XML acima seria mantido em seu CLASSPATH de preferência junto com o arquivo de classe. Deixe-nos ter nossa classe de ação do funcionário como segue, sem tervalidate() método -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}O resto da configuração permanecerá como no exemplo anterior, agora se você executar o aplicativo, ele produzirá o mesmo resultado que recebemos no exemplo anterior.
A vantagem de ter um arquivo xml para armazenar a configuração permite separar a validação do código da aplicação. Você pode fazer com que um desenvolvedor escreva o código e um analista de negócios para criar os arquivos xml de validação. Outra coisa a observar são os tipos de validador que estão disponíveis por padrão.
Existem muitos outros validadores que vêm por padrão com o Struts. Os validadores comuns incluem validador de data, validador Regex e validador de comprimento de string. Verifique o link a seguir para obter mais detalhes Struts - Validadores baseados em XML .
Internacionalização (i18n) é o processo de planejamento e implementação de produtos e serviços para que possam ser facilmente adaptados a idiomas e culturas locais específicos, um processo denominado localização. O processo de internacionalização é chamado de capacitação de tradução ou localização.
Internacionalização é abreviada i18n porque a palavra começa com a letra “i” e termina com “n”, e há 18 caracteres entre o primeiro i e o último n.
Struts2 fornece localização, ou seja, suporte de internacionalização (i18n) por meio de pacotes de recursos, interceptores e bibliotecas de tags nos seguintes locais -
As Tags da IU
Mensagens e erros.
Dentro das classes de ação.
Pacotes de Recursos
Struts2 usa pacotes de recursos para fornecer várias opções de idioma e local para os usuários do aplicativo da web. Você não precisa se preocupar em escrever páginas em diferentes idiomas. Tudo que você precisa fazer é criar um pacote de recursos para cada idioma que você deseja. Os pacotes de recursos conterão títulos, mensagens e outros textos no idioma do seu usuário. Pacotes de recursos são o arquivo que contém os pares de chave / valor para o idioma padrão de seu aplicativo.
O formato de nomenclatura mais simples para um arquivo de recurso é -
bundlename_language_country.propertiesAqui, bundlenamepoderia ser ActionClass, Interface, SuperClass, Model, Package, Global resource properties. Próxima partelanguage_country representa a localidade do país, por exemplo, a localidade do espanhol (Espanha) é representada por es_ES e a localidade do inglês (Estados Unidos) é representada por en_US etc. onde você pode ignorar a parte do país, que é opcional.
Quando você faz referência a um elemento de mensagem por sua chave, a estrutura do Struts procura por um pacote de mensagens correspondente na seguinte ordem -
- ActionClass.properties
- Interface.properties
- SuperClass.properties
- model.properties
- package.properties
- struts.properties
- global.properties
Para desenvolver seu aplicativo em vários idiomas, você deve manter vários arquivos de propriedades correspondentes a esses idiomas / localidade e definir todo o conteúdo em termos de pares de chave / valor.
Por exemplo, se você for desenvolver seu aplicativo para inglês dos EUA (padrão), espanhol e francês, terá que criar três arquivos de propriedades. Aqui vou usarglobal.properties arquivo apenas, você também pode usar diferentes arquivos de propriedades para separar diferentes tipos de mensagens.
global.properties - Por padrão, o inglês (Estados Unidos) será aplicado
global_fr.properties - Isso será usado para a localidade de Franquia.
global_es.properties - Isso será usado para o idioma espanhol.
Acesse as mensagens
Existem várias maneiras de acessar os recursos de mensagem, incluindo getText, a tag de texto, o atributo-chave das tags da IU e a tag i18n. Vamos vê-los em breve -
Mostrar i18n texto, use uma chamada para getText na tag de propriedade ou qualquer outra tag, como as tags da IU da seguinte maneira -
<s:property value = "getText('some.key')" />o text tag recupera uma mensagem do pacote de recursos padrão, ou seja, struts.properties
<s:text name = "some.key" />o i18n tagempurra um pacote de recursos arbitrário para a pilha de valor. Outras tags dentro do escopo da tag i18n podem exibir mensagens desse pacote de recursos -
<s:i18n name = "some.package.bundle">
<s:text name = "some.key" />
</s:i18n>o key atributo da maioria das tags de IU pode ser usado para gerar uma mensagem de um pacote de recursos -
<s:textfield key = "some.key" name = "textfieldName"/>Exemplo de localização
Vamos direcionar para criar index.jspdo capítulo anterior em vários idiomas. O mesmo arquivo seria escrito da seguinte maneira -
<%@ 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>Employee Form with Multilingual Support</title>
</head>
<body>
<h1><s:text name = "global.heading"/></h1>
<s:url id = "indexEN" namespace="/" action = "locale" >
<s:param name = "request_locale" >en</s:param>
</s:url>
<s:url id = "indexES" namespace="/" action = "locale" >
<s:param name = "request_locale" >es</s:param>
</s:url>
<s:url id = "indexFR" namespace="/" action = "locale" >
<s:param name = "request_locale" >fr</s:param>
</s:url>
<s:a href="%{indexEN}" >English</s:a>
<s:a href="%{indexES}" >Spanish</s:a>
<s:a href="%{indexFR}" >France</s:a>
<s:form action = "empinfo" method = "post" namespace = "/">
<s:textfield name = "name" key = "global.name" size = "20" />
<s:textfield name = "age" key = "global.age" size = "20" />
<s:submit name = "submit" key = "global.submit" />
</s:form>
</body>
</html>Vamos criar success.jsp arquivo que será invocado caso a ação definida retorne SUCCESS.
<%@ 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>Success</title>
</head>
<body>
<s:property value = "getText('global.success')" />
</body>
</html>Aqui, precisaríamos criar as duas ações a seguir. (a) Primeira ação a para cuidar do Locale e exibir o mesmo arquivo index.jsp com idioma diferente (b) Outra ação é cuidar do próprio envio do formulário. Ambas as ações retornarão SUCCESS, mas tomaremos ações diferentes com base nos valores de retorno porque nosso propósito é diferente para ambas as ações
Ação para cuidar do Locale
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}Ação para enviar o formulário
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Agora vamos criar os três seguintes global.properties arquivos e colocá-los em CLASSPATH -
global.properties
global.name = Name
global.age = Age
global.submit = Submit
global.heading = Select Locale
global.success = Successfully authenticatedglobal_fr.properties
global.name = Nom d'utilisateur
global.age = l'âge
global.submit = Soumettre des
global.heading = Sé lectionnez Local
global.success = Authentifi é avec succèsglobal_es.properties
global.name = Nombre de usuario
global.age = Edad
global.submit = Presentar
global.heading = seleccionar la configuracion regional
global.success = Autenticado correctamenteVamos criar o nosso struts.xml com duas ações da seguinte forma -
<?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.devMode" value = "true" />
<constant name = "struts.custom.i18n.resources" value = "global" />
<package name = "helloworld" extends = "struts-default" namespace="/">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
<action name = "locale"
class = "com.tutorialspoint.struts2.Locale"
method = "execute">
<result name = "success">/index.jsp</result>
</action>
</package>
</struts>A seguir está o conteúdo de web.xml arquivo -
<?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>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Agora selecione qualquer um dos idiomas, digamos que selecionamos Spanish, ele exibiria o seguinte resultado -
Você também pode tentar a língua francesa. Finalmente, vamos tentar clicarSubmit botão quando estamos na localidade espanhola, ele exibirá a seguinte tela -
Parabéns, agora você tem uma página multilíngue, pode lançar seu site globalmente.
Tudo em uma solicitação HTTP é tratado como um Stringpelo protocolo. Isso inclui números, booleanos, inteiros, datas, decimais e tudo mais. No entanto, na classe Struts, você pode ter propriedades de qualquer tipo de dados.
Como o Struts faz o autowire das propriedades para você?
Struts usa uma variedade de conversores de tipo sob as tampas para fazer o trabalho pesado.
Por exemplo, se você tiver um atributo integer em sua classe Action, o Struts converte automaticamente o parâmetro de solicitação no atributo integer sem que você faça nada. Por padrão, o Struts vem com vários conversores de tipo
Se você estiver usando qualquer um dos conversores listados abaixo, não precisa se preocupar -
- Inteiro, Flutuante, Duplo, Decimal
- Data e data e hora
- Matrizes e coleções
- Enumerations
- Boolean
- BigDecimal
Às vezes, quando você está usando seu próprio tipo de dados, é necessário adicionar seus próprios conversores para tornar o Struts ciente de como converter esses valores antes de exibi-los. Considere a seguinte classe POJOEnvironment.java.
package com.tutorialspoint.struts2;
public class Environment {
private String name;
public Environment(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Esta é uma classe muito simples que tem um atributo chamado name, então nada de especial sobre esta classe. Vamos criar outra classe que contenha informações sobre o sistema -SystemDetails.java.
Para o propósito deste exercício, codifiquei o Ambiente para "Desenvolvimento" e o Sistema Operacional para "Windows XP SP3".
Em um projeto em tempo real, você obteria essas informações da configuração do sistema.
Deixe-nos ter a seguinte classe de ação -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class SystemDetails extends ActionSupport {
private Environment environment = new Environment("Development");
private String operatingSystem = "Windows XP SP3";
public String execute() {
return SUCCESS;
}
public Environment getEnvironment() {
return environment;
}
public void setEnvironment(Environment environment) {
this.environment = environment;
}
public String getOperatingSystem() {
return operatingSystem;
}
public void setOperatingSystem(String operatingSystem) {
this.operatingSystem = operatingSystem;
}
}A seguir, vamos criar um arquivo JSP simples System.jsp para exibir as informações do ambiente e do sistema operacional.
<%@ 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>System Details</title>
</head>
<body>
Environment: <s:property value = "environment"/><br/>
Operating System:<s:property value = "operatingSystem"/>
</body>
</html>Vamos conectar o system.jsp e a SystemDetails.java aula juntos usando struts.xml.
A classe SystemDetails tem um método execute () simples que retorna a string "SUCCESS"
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "system"
class = "com.tutorialspoint.struts2.SystemDetails"
method = "execute">
<result name = "success">/System.jsp</result>
</action>
</package>
</struts>Clique com o botão direito no nome do projeto e clique Export > WAR File para criar um arquivo de guerra.
Em seguida, implante esse WAR no diretório webapps do Tomcat.
Finalmente, inicie o servidor Tomcat e tente acessar o URL http://localhost:8080/HelloWorldStruts2/system.action. Isso produzirá a seguinte tela -
O que há de errado com a saída acima? Struts sabe como exibir e converter a string "Windows XP SP3" e outros tipos de dados internos, mas não sabe o que fazer com a propriedade deEnvironmenttipo. É simplesmente chamadotoString() método na aula
Para resolver este problema, vamos agora criar e registrar um simples TypeConverter para a aula de Meio Ambiente.
Crie uma classe chamada EnvironmentConverter.java com o seguinte.
package com.tutorialspoint.struts2;
import java.util.Map;
import org.apache.struts2.util.StrutsTypeConverter;
public class EnvironmentConverter extends StrutsTypeConverter {
@Override
public Object convertFromString(Map context, String[] values, Class clazz) {
Environment env = new Environment(values[0]);
return env;
}
@Override
public String convertToString(Map context, Object value) {
Environment env = (Environment) value;
return env == null ? null : env.getName();
}
}o EnvironmentConverter estende o StrutsTypeConverter classe e diz ao Struts como converter Environment em String e vice-versa substituindo dois métodos que são convertFromString() e convertToString().
Vamos agora registrar este conversor antes de usá-lo em nosso aplicativo. Existem duas maneiras de registrar um conversor.
Se o conversor for usado apenas em uma ação específica, você terá que criar um arquivo de propriedade que precisa ser nomeado como '[action-class]'converstion.properties.
No nosso caso, criamos um arquivo chamado SystemDetails-converstion.properties com a seguinte entrada de registro -
environment = com.tutorialspoint.struts2.EnvironmentConverterNo exemplo acima, "ambiente" é o nome da propriedade no SystemDetails.java classe e estamos dizendo ao Struts para usar o EnvironmentConverter para converter de e para esta propriedade.
No entanto, não vamos fazer isso, em vez disso, vamos registrar este conversor globalmente, para que possa ser usado em todo o aplicativo. Para fazer isso, crie um arquivo de propriedades chamadoxwork-conversion.properties no WEBINF/classes pasta com a seguinte linha
com.tutorialspoint.struts2.Environment = \
com.tutorialspoint.struts2.EnvironmentConverterIsso simplesmente registra o conversor globalmente, para que Strutspode fazer a conversão automaticamente sempre que encontrar um objeto do tipo Environment. Agora, se você recompilar e executar novamente o programa, você obterá uma saída melhor da seguinte forma -
Obviamente, agora o resultado será melhor, o que significa que nosso conversor Struts está funcionando bem.
É assim que você pode criar vários conversores e registrá-los para uso de acordo com seus requisitos.
Antes de iniciar o tutorial real para este capítulo, vamos dar uma olhada em algumas definições dadas por https://struts.apache.org-
| Sr. Não | Termo e descrição |
|---|---|
| 1 | TAG Um pequeno trecho de código executado de dentro do JSP, FreeMarker ou Velocity. |
| 2 | TEMPLATE Um pedaço de código, geralmente escrito em FreeMarker, que pode ser renderizado por certas tags (tags HTML). |
| 3 | THEME Uma coleção de modelos agrupados para fornecer funcionalidade comum. |
Eu também sugeriria passar pelo capítulo Localização do Struts2 porque usaremos o mesmo exemplo mais uma vez para realizar nosso exercício.
Quando você usa um Struts 2tag como <s: submit ...>, <s: textfield ...> etc em sua página da web, a estrutura do Struts 2 gera código HTML com um estilo e layout pré-configurados. O Struts 2 vem com três temas integrados -
| Sr. Não | Tema e descrição |
|---|---|
| 1 | SIMPLE theme Um tema minimalista sem "sinos e assobios". Por exemplo, a tag textfield renderiza a tag HTML <input /> sem um rótulo, validação, relatório de erro ou qualquer outra formatação ou funcionalidade. |
| 2 | XHTML theme Este é o tema padrão usado pelo Struts 2 e fornece todos os fundamentos que o tema simples fornece e adiciona vários recursos, como layout de tabela de duas colunas padrão para o HTML, rótulos para cada um dos HTML, validação e relatório de erros, etc. |
| 3 | CSS_XHTML theme Este tema fornece todos os fundamentos que o tema simples fornece e adiciona vários recursos, como layout padrão baseado em CSS de duas colunas, usando <div> para as tags HTML Struts, rótulos para cada uma das tags HTML Struts, colocados de acordo com a folha de estilo CSS . |
Conforme mencionado acima, se você não especificar um tema, o Struts 2 usará o tema xhtml por padrão. Por exemplo, este Struts 2 seleciona a tag -
<s:textfield name = "name" label = "Name" />gera a seguinte marcação HTML -
<tr>
<td class="tdLabel">
<label for = "empinfo_name" class="label">Name:</label>
</td>
<td>
<input type = "text" name = "name" value = "" id = "empinfo_name"/>
</td>
</tr>Aqui empinfo é o nome da ação definido no arquivo struts.xml.
Selecionando Temas
Você pode especificar o tema de acordo com o Struts 2, base de tag ou pode usar um dos seguintes métodos para especificar qual tema o Struts 2 deve usar -
O atributo de tema na tag específica
O atributo de tema em uma tag de formulário circundante
O atributo de escopo de página denominado "tema"
O atributo com escopo de solicitação denominado "theme"
O atributo com escopo de sessão denominado "tema"
O atributo do escopo do aplicativo denominado "theme"
A propriedade struts.ui.theme em struts.properties (o padrão é xhtml)
A seguir está a sintaxe para especificá-los no nível de tag se você estiver disposto a usar temas diferentes para tags diferentes -
<s:textfield name = "name" label = "Name" theme="xhtml"/>Porque não é muito prático usar temas por tag, então simplesmente podemos especificar a regra em struts.properties arquivo usando as seguintes tags -
# Standard UI theme
struts.ui.theme = xhtml
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the default template type. Either ftl, vm, or jsp
struts.ui.templateSuffix = ftlA seguir está o resultado que pegamos no capítulo de localização, onde usamos o tema padrão com uma configuração struts.ui.theme = xhtml dentro struts-default.properties que vem por padrão no arquivo struts2-core.xy.z.jar.
Como funciona um tema?
Para um determinado tema, cada tag struts tem um modelo associado como s:textfield → text.ftl e s:password → password.ftl etc.
Esses arquivos de modelo vêm compactados no arquivo struts2-core.xy.z.jar. Esses arquivos de modelo mantêm um layout HTML predefinido para cada tag.
Nesse caminho, Struts 2 framework gera código de marcação HTML final usando tags Sturts e modelos associados.
Struts 2 tags + Associated template file = Final HTML markup code.Os modelos padrão são escritos no FreeMarker e têm uma extensão .ftl.
Você também pode projetar seus modelos usando velocidade ou JSP e, de acordo com isso, definir a configuração em struts.properties usando struts.ui.templateSuffix e struts.ui.templateDir.
Criação de novos temas
A maneira mais simples de criar um novo tema é copiar qualquer um dos arquivos de tema / modelo existentes e fazer as modificações necessárias.
Vamos começar criando uma pasta chamada templateem WebContent / WEBINF / classes e uma subpasta com o nome do nosso novo tema. Por exemplo, WebContent / WEB-INF / classes / template / mytheme .
A partir daqui, você pode começar a construir modelos do zero, ou também pode copiar os modelos do Struts2 distribution onde você pode modificá-los conforme necessário no futuro.
Vamos modificar o modelo padrão existente xhtmlpara fins de aprendizagem. Agora, vamos copiar o conteúdo de struts2-core-xyzjar / template / xhtml para nosso diretório de tema e modificar apenas o arquivo WebContent / WEBINF / classes / template / mytheme / control .ftl. Quando abrimos control.ftl, que terá as seguintes linhas -
<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>Vamos mudar o arquivo acima control.ftl ter o seguinte conteúdo -
<table style = "border:1px solid black;">Se você verificar form.ftl então você vai achar que control.ftlé usado neste arquivo, mas form.ftl está se referindo a este arquivo do xhtml theme. Então, vamos mudá-lo da seguinte maneira -
<#include "/${parameters.templateDir}/xhtml/form-validate.ftl" />
<#include "/${parameters.templateDir}/simple/form-common.ftl" /> <#if (parameters.validate?default(false))> onreset = "${parameters.onreset?default('clearErrorMessages(this);\
clearErrorLabels(this);')}"
<#else>
<#if parameters.onreset??>
onreset="${parameters.onreset?html}" </#if> </#if> #include "/${parameters.templateDir}/mytheme/control.ftl" />Suponho que você não teria muito entendimento do FreeMarker linguagem de modelo, você ainda pode ter uma boa idéia do que deve ser feito olhando os arquivos .ftl.
No entanto, vamos salvar as alterações acima e voltar ao nosso exemplo de localização e criar o WebContent/WEB-INF/classes/struts.properties arquivo com o seguinte conteúdo
# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftlAgora, após esta alteração, clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2. Isso produzirá a seguinte tela -
Você pode ver uma borda ao redor do componente do formulário que é resultado da mudança que fizemos em nosso tema depois de copiá-lo do tema xhtml. Se você se esforçar pouco para aprender o FreeMarker, poderá criar ou modificar seus temas com muita facilidade.
Espero que agora você tenha um entendimento básico sobre Sturts 2 temas e templates, não é?
Strutsfornece uma maneira mais fácil de lidar com exceções não detectadas e redirecionar os usuários para uma página de erro dedicada. Você pode configurar facilmente o Struts para ter diferentes páginas de erro para diferentes exceções.
O Struts facilita o tratamento de exceções com o uso do interceptor de "exceção". O interceptor de "exceção" é incluído como parte da pilha padrão, então você não precisa fazer nada extra para configurá-lo. Ele está disponível pronto para uso.
Vamos ver um exemplo simples de Hello World com algumas modificações no arquivo HelloWorldAction.java. Aqui, introduzimos deliberadamente uma exceção NullPointer em nossoHelloWorldAction código de ação.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport{
private String name;
public String execute(){
String x = null;
x = x.substring(0);
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Vamos manter o conteúdo de HelloWorld.jsp como segue -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>A seguir está o conteúdo de index.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 From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>Seu struts.xml deve ser parecido com -
<?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.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>
</package>
</struts>Agora clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Insira um valor "Struts2" e envie a página. Você deve ver a seguinte página -
Conforme mostrado no exemplo acima, o interceptor de exceção padrão faz um ótimo trabalho ao lidar com a exceção.
Vamos agora criar uma página de erro dedicada para nossa exceção. Crie um arquivo chamadoError.jsp com os seguintes conteúdos -
<%@ 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></title>
</head>
<body>
This is my custom error page
</body>
</html>Vamos agora configurar o Struts para usar esta página de erro no caso de uma exceção. Vamos modificar ostruts.xml como segue -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Conforme mostrado no exemplo acima, agora configuramos o Struts para usar o Error.jsp dedicado para o NullPointerException. Se você executar novamente o programa agora, verá a seguinte saída -
Além disso, o framework Struts2 vem com um interceptor de "registro" para registrar as exceções. Ao permitir que o logger registre as exceções não capturadas, podemos facilmente olhar para o rastreamento da pilha e descobrir o que deu errado
Mapeamentos de exceção global
Vimos como podemos lidar com exceções específicas de ações. Podemos definir uma exceção globalmente que se aplicará a todas as ações. Por exemplo, para capturar as mesmas exceções NullPointerException, poderíamos adicionar<global-exception-mappings...> tag dentro da tag <package ...> e sua tag <result ...> deve ser adicionada dentro da tag <action ...> no arquivo struts.xml da seguinte maneira -
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<global-exception-mappings>
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
</global-exception-mappings>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Conforme mencionado anteriormente, o Struts oferece duas formas de configuração. A maneira tradicional é usar ostruts.xmlarquivo para todas as configurações. Vimos muitos exemplos disso no tutorial até agora. A outra maneira de configurar o Struts é usando o recurso Java 5 Annotations. Usando as anotações do struts, podemos alcançarZero Configuration.
Para começar a usar anotações em seu projeto, certifique-se de incluir os seguintes arquivos jar em seu WebContent/WEB-INF/lib pasta -
- struts2-convention-plugin-x.y.z.jar
- asm-x.y.jar
- antlr-x.y.z.jar
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Agora, vamos ver como você pode acabar com a configuração disponível no struts.xml arquivo e substituí-lo por anotações.
Para explicar o conceito de Anotação no Struts2, teríamos que reconsiderar nosso exemplo de validação explicado no capítulo Validações do Struts2 .
Aqui, vamos dar um exemplo de um Funcionário cujo nome e idade seriam capturados usando uma página simples, e colocaremos duas validações para garantir que ÜSER sempre insira um nome e a idade deve estar entre 28 e 65 anos.
Vamos começar com a página JSP principal do exemplo.
Criar página principal
Vamos escrever o arquivo JSP da página principal index.jsp, que é usado para coletar informações relacionadas aos funcionários mencionadas acima.
<%@ 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>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>O index.jsp faz uso da tag Struts, que ainda não cobrimos, mas vamos estudá-los em capítulos relacionados a tags. Mas, por enquanto, apenas suponha que a tag s: textfield imprime um campo de entrada e s: submit imprime um botão de envio. Usamos a propriedade label para cada tag, que cria um rótulo para cada tag.
Criar Vistas
Usaremos arquivo JSP success.jsp que será invocado caso a ação definida retorne SUCCESS.
<%@ 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>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Criar ação
Este é o local onde a anotação é usada. Vamos redefinir a classe de açãoEmployee com anotação e, em seguida, adicione um método chamado validate () como mostrado abaixo em Employee.javaArquivo. Certifique-se de que sua classe de ação estende oActionSupport classe, caso contrário, seu método de validação não será executado.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import com.opensymphony.xwork2.validator.annotations.*;
@Results({
@Result(name = "success", Location = "/success.jsp"),
@Result(name = "input", Location = "/index.jsp")
})
public class Employee extends ActionSupport {
private String name;
private int age;
@Action(value = "/empinfo")
public String execute() {
return SUCCESS;
}
@RequiredFieldValidator( message = "The name is required" )
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@IntRangeFieldValidator(message = "Age must be in between 28 and 65", min = "29", max = "65")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Usamos algumas anotações neste exemplo. Deixe-me examiná-los um por um -
Primeiro, incluímos o Resultsanotação. Uma anotação de resultados é uma coleção de resultados.
Abaixo da anotação de resultados, temos duas anotações de resultados. As anotações de resultado têm onameque correspondem ao resultado do método execute. Eles também contêm um local para qual visualização deve ser exibida, correspondendo ao valor de retorno de execute ()
A próxima anotação é o Actionanotação. Isso é usado para decorar o método execute (). O método Action também aceita um valor que é a URL na qual a ação é chamada.
Finalmente, usei dois validationanotações. Eu configurei o validador de campo obrigatório emname campo e o validador de intervalo inteiro no agecampo. Também especifiquei uma mensagem personalizada para as validações.
Arquivos de configuração
Nós realmente não precisamos struts.xml arquivo de configuração, vamos remover esse arquivo e verificar o conteúdo de web.xml arquivo -
<?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>
<init-param>
<param-name>struts.devMode</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Isso produzirá a seguinte tela -
Agora não insira nenhuma informação necessária, basta clicar em Submitbotão. Você verá o seguinte resultado -
Insira as informações necessárias, mas insira um campo De errado, digamos que o nome seja "teste" e a idade 30 e, por fim, clique em Submitbotão. Você verá o seguinte resultado -
Tipos de anotações do Struts 2
Os aplicativos Struts 2 podem usar anotações Java 5 como alternativa à configuração de propriedades XML e Java. Você pode verificar a lista das anotações mais importantes relacionadas a diferentes categorias -
Tipos de anotações do Struts 2 .
As tags do Struts 2 possuem um conjunto de tags que facilita o controle do fluxo de execução da página.
A seguir está a lista de tags de controle importantes do Struts 2 -
As tags If e Else
Essas tags executam o fluxo de condições básicas encontradas em todos os idiomas.
'If' tag é usada sozinha ou com 'Else If' Tag e / ou único / múltiplo 'Else' Marque como mostrado abaixo -
<s:if test = "%{false}">
<div>Will Not Be Executed</div>
</s:if>
<s:elseif test = "%{true}">
<div>Will Be Executed</div>
</s:elseif>
<s:else>
<div>Will Not Be Executed</div>
</s:else>Verifique o exemplo detalhado
As tags do iterador
este iteratorirá iterar sobre um valor. Um valor iterável pode ser o arquivo itherjava.util.Collection ou java.util.Iterator. Durante a iteração em um iterador, você pode usarSort tag para classificar o resultado ou SubSet tag para obter um subconjunto da lista ou matriz.
O exemplo a seguir recupera o valor do método getDays () do objeto atual na pilha de valores e o usa para iterar.
A tag <s: property /> imprime o valor atual do iterador.
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>Verifique o exemplo detalhado
The Merge Tag
Estes merge tag leva duas ou mais listas como parâmetros e mescla-as todas como mostrado abaixo -
<s:merge var = "myMergedIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:merge>
<s:iterator value = "%{#myMergedIterator}">
<s:property />
</s:iterator>Verifique o exemplo detalhado
A Tag Append
Estes append tag pegar duas ou mais listas como parâmetros e anexá-los todos juntos, conforme mostrado abaixo -
<s:append var = "myAppendIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:append>
<s:iterator value = "%{#myAppendIterator}">
<s:property />
</s:iterator>Verifique o exemplo detalhado
A Tag Geradora
Estes generatortag gera um iterador com base no atributo val fornecido. A seguinte tag do gerador gera um iterador e o imprime usando a tag do iterador.
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>Verifique o exemplo detalhado
The Struts 2 data tagssão usados principalmente para manipular os dados exibidos em uma página. Listadas abaixo estão as tags de dados importantes: <Comece aqui>
A Tag de Ação
Essa tag permite que os desenvolvedores chamem ações diretamente de uma página JSP, especificando o nome da ação e um namespace opcional. O conteúdo do corpo da tag é usado para renderizar os resultados da ação. Qualquer processador de resultado definido para esta ação em struts.xml será ignorado, a menos que o parâmetro executeResult seja especificado.
<div>Tag to execute the action</div>
<br />
<s:action name = "actionTagAction" executeresult = "true" />
<br />
<div>To invokes special method in action class</div>
<br />
<s:action name = "actionTagAction!specialMethod" executeresult = "true" />Verifique o exemplo detalhado
A Tag Incluir
Estes include será usado para incluir um arquivo JSP em outra página JSP.
<-- First Syntax -->
<s:include value = "myJsp.jsp" />
<-- Second Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1" value = "value2" />
<s:param name = "param2" value = "value2" />
</s:include>
<-- Third Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1">value1</s:param>
<s:param name = "param2">value2</s:param>
</s:include>Verifique o exemplo detalhado
The Bean Tag
Estes beantag instancia uma classe que está em conformidade com a especificação JavaBeans. Esta tag tem um corpo que pode conter vários elementos Param para definir qualquer método modificador nessa classe. Se o atributo var for definido no BeanTag, ele colocará o bean instanciado no Contexto da pilha.
<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
<s:param name = "first" value = "20"/>
<s:param name = "last" value = "25" />
</s:bean>Verifique o exemplo detalhado
The Date Tag
Estes datetag permitirá que você formate uma data de forma rápida e fácil. Você pode especificar um formato personalizado (por exemplo, "dd / MM / aaaa hh: mm"), pode gerar notações legíveis (como "em 2 horas, 14 minutos") ou pode simplesmente voltar a um formato predefinido com chave 'struts.date.format' em seu arquivo de propriedades.
<s:date name = "person.birthday" format = "dd/MM/yyyy" />
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}" />
<s:date name = "person.birthday" nice="true" />
<s:date name = "person.birthday" />Verifique o exemplo detalhado
A tag Param
Estes paramtag pode ser usada para parametrizar outras tags. Essa tag possui os dois parâmetros a seguir.
name (String) - o nome do parâmetro
valor (objeto) - o valor do parâmetro
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>Verifique o exemplo detalhado
The Property Tag
Estes property tag é usada para obter a propriedade de um valor, que assumirá como padrão o topo da pilha se nenhum for especificado.
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty" />
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value" />
</s:push>Verifique o exemplo detalhado
The Push Tag
Estes push tag é usada para empurrar o valor na pilha para uso simplificado.
<s:push value = "user">
<s:propery value = "firstName" />
<s:propery value = "lastName" />
</s:push>Verifique o exemplo detalhado
The Set Tag
Estes settag atribui um valor a uma variável em um escopo especificado. É útil quando você deseja atribuir uma variável a uma expressão complexa e, em seguida, simplesmente fazer referência a essa variável a cada vez, em vez da expressão complexa. Os escopos disponíveis sãoapplication, session, request, page e action.
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>Verifique o exemplo detalhado
A Tag de Texto
Estes text tag é usada para processar uma mensagem de texto I18n.
<!-- First Example -->
<s:i18n name = "struts.action.test.i18n.Shop">
<s:text name = "main.title"/>
</s:i18n>
<!-- Second Example -->
<s:text name = "main.title" />
<!-- Third Examlpe -->
<s:text name = "i18n.label.greetings">
<s:param >Mr Smith</s:param>
</s:text>Verifique o exemplo detalhado
A URL Tag
Estes url tag é usada para criar um URL.
<-- Example 1 -->
<s:url value = "editGadget.action">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 2 -->
<s:url action = "editGadget">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 3-->
<s:url includeParams="get">
<s:param name = "id" value = "%{'22'}" />
</s:url>Verifique o exemplo detalhado
A lista de formtags é um subconjunto de tags de interface do usuário do Struts. Essas tags ajudam na renderização da interface com o usuário necessária para os aplicativos da web Struts e podem ser categorizadas em três categorias. Este capítulo o levará através de todos os três tipos de tags de IU -
Tags de IU simples
Já usamos essas tags em nossos exemplos, vamos escová-las neste capítulo. Vamos dar uma olhada em uma página de visualização simplesemail.jsp com várias tags de IU simples -
<%@ 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>
<s:head/>
<title>Hello World</title>
</head>
<body>
<s:div>Email Form</s:div>
<s:text name = "Please fill in the form below:" />
<s:form action = "hello" method = "post" enctype = "multipart/form-data">
<s:hidden name = "secret" value = "abracadabra"/>
<s:textfield key = "email.from" name = "from" />
<s:password key = "email.password" name = "password" />
<s:textfield key = "email.to" name = "to" />
<s:textfield key = "email.subject" name = "subject" />
<s:textarea key = "email.body" name = "email.body" />
<s:label for = "attachment" value = "Attachment"/>
<s:file name = "attachment" accept = "text/html,text/plain" />
<s:token />
<s:submit key = "submit" />
</s:form>
</body>
</html>Se você conhece HTML, todas as tags usadas são tags HTML muito comuns com um prefixo adicional s:junto com cada tag e atributos diferentes. Quando executamos o programa acima, obtemos a seguinte interface de usuário, desde que você tenha configurado o mapeamento adequado para todas as chaves usadas.
Conforme mostrado, o s: head gera os elementos javascript e folha de estilo necessários para o aplicativo Struts2.
Em seguida, temos os elementos s: div e s: text. O s: div é usado para renderizar um elemento HTML Div. Isso é útil para pessoas que não gostam de misturar tags HTML e Struts. Para essas pessoas, eles têm a opção de usar s: div para renderizar um div.
O s: text conforme mostrado é usado para renderizar um texto na tela.
Em seguida, temos a tag famiilar s: form. A tag s: form tem um atributo de ação que determina para onde enviar o formulário. Como temos um elemento de upload de arquivo no formulário, temos que definir o enctype como multipart. Caso contrário, podemos deixar em branco.
No final da tag do formulário, temos a tag s: submit. Isso é usado para enviar o formulário. Quando o formulário é enviado, todos os valores do formulário são submetidos à ação especificada na tag s: form.
Dentro do s: form, temos um atributo oculto chamado secret. Isso renderiza um elemento oculto no HTML. No nosso caso, o elemento "secreto" tem o valor "abracadabra". Este elemento não é visível para o usuário final e é usado para transportar o estado de uma visualização para outra.
Em seguida, temos as tags s: label, s: textfield, s: password es: textarea. Eles são usados para renderizar o rótulo, campo de entrada, senha e área de texto, respectivamente. Vimos isso em ação no exemplo "Struts - Enviando e-mail".
O importante a notar aqui é o uso do atributo "chave". O atributo "chave" é usado para buscar o rótulo para esses controles do arquivo de propriedades. Já cobrimos esse recurso no capítulo Localização do Struts2, internacionalização.
Então, temos a tag s: file que renderiza um componente de upload de arquivo de entrada. Este componente permite ao usuário fazer upload de arquivos. Neste exemplo, usamos o parâmetro "aceitar" da tag s: file para especificar quais tipos de arquivo podem ser carregados.
Finalmente, temos a tag s: token. A marca de token gera um token único que é usado para descobrir se um formulário foi submetido duas vezes
Quando o formulário é renderizado, uma variável oculta é colocada como o valor do token. Digamos, por exemplo, que o token é "ABC". Quando este formulário é enviado, o Struts Fitler verifica o token em relação ao token armazenado na sessão. Se corresponder, remove o token da sessão. Agora, se o formulário for reenviado acidentalmente (atualizando ou clicando no botão Voltar do navegador), o formulário será reenviado com "ABC" como token. Nesse caso, o filtro verifica o token em relação ao token armazenado na sessão novamente. Mas, como o token "ABC" foi removido da sessão, ele não corresponderá e o filtro do Struts rejeitará a solicitação.
Tags da IU do grupo
As tags da IU do grupo são usadas para criar o botão de rádio e a caixa de seleção. Vamos dar uma olhada em uma página de visualização simplesHelloWorld.jsp com tags de caixa de seleção e botão de opção -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "hello.action">
<s:radio label = "Gender" name = "gender" list="{'male','female'}" />
<s:checkboxlist label = "Hobbies" name = "hobbies"
list = "{'sports','tv','shopping'}" />
</s:form>
</body>
</html>Quando executamos o programa acima, nossa saída será semelhante à seguinte -
Vejamos o exemplo agora. No primeiro exemplo, estamos criando um botão de opção simples com o rótulo "Gênero". O atributo name é obrigatório para a tag do botão de rádio, então especificamos um nome que é "gênero". Em seguida, fornecemos uma lista de gênero. A lista é preenchida com os valores "masculino" e "feminino". Portanto, na saída, obtemos um botão de rádio com dois valores.
No segundo exemplo, estamos criando uma lista de caixas de seleção. Isso é para reunir os hobbies do usuário. O usuário pode ter mais de um hobby e, portanto, estamos usando a caixa de seleção em vez do botão de rádio. A caixa de seleção é preenchida com a lista "esportes", "TV" e "Compras". Isso apresenta os hobbies como uma lista de caixas de seleção.
Selecionar Tags da IU
Vamos explorar as diferentes variações do Select Tag oferecido pelo Struts. Vamos dar uma olhada em uma página de visualização simplesHelloWorld.jsp com tags selecionadas -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "login.action">
<s:select name = "username" label = "Username"
list = "{'Mike','John','Smith'}" />
<s:select label = "Company Office" name = "mySelection"
value = "%{'America'}" list="%{#{'America':'America'}}">
<s:optgroup label = "Asia"
list = "%{#{'India':'India','China':'China'}}" />
<s:optgroup label = "Europe"
list="%{#{'UK':'UK','Sweden':'Sweden','Italy':'Italy'}}" />
</s:select>
<s:combobox label = "My Sign" name = "mySign"
list = "#{'aries':'aries','capricorn':'capricorn'}" headerkey = "-1"
headervalue = "--- Please Select ---" emptyOption = "true" value = "capricorn" />
<s:doubleselect label = "Occupation" name = "occupation"
list = "{'Technical','Other'}" doublename = "occupations2"
doubleList="top == 'Technical' ?
{'I.T', 'Hardware'} : {'Accounting', 'H.R'}" />
</s:form>
</body>
</html>Quando executamos o programa acima, nossa saída será semelhante à seguinte -
Vamos agora examinar os casos individuais, um por um.
Primeiro, a tag de seleção renderiza a caixa de seleção HTML. No primeiro exemplo, estamos criando uma caixa de seleção simples com o nome "nome de usuário" e o rótulo "nome de usuário". A caixa de seleção será preenchida com uma lista que contém os nomes Mike, John e Smith.
No segundo exemplo, nossa empresa tem sede na América. Também possui escritórios globais na Ásia e na Europa. Queremos exibir os escritórios em uma caixa de seleção, mas queremos agrupar os escritórios globais pelo nome do continente. É aqui que o optgroup é útil. Usamos a tag s: optgroup para criar um novo grupo. Damos ao grupo um rótulo e uma lista separada.
No terceiro exemplo, o combobox é usado. Uma caixa de combinação é uma combinação de um campo de entrada e uma caixa de seleção. O usuário pode selecionar um valor da caixa de seleção e, nesse caso, o campo de entrada é preenchido automaticamente com o valor que o usuário selecionou. Se o usuário inserir um valor diretamente, nenhum valor da caixa de seleção será selecionado.
Em nosso exemplo, temos a caixa de combinação listando os signos solares. A caixa de seleção lista apenas quatro entradas que permitem ao usuário digitar seu signo solar, se não estiver na lista. Também adicionamos uma entrada de cabeçalho à caixa de seleção. A entrada do cabeçalho é aquela exibida na parte superior da caixa de seleção. No nosso caso, queremos exibir "Selecione". Se o usuário não selecionar nada, assumimos -1 como o valor. Em alguns casos, não queremos que o usuário selecione um valor vazio. Nessas condições, seria necessário definir a propriedade "emptyOption" como false. Finalmente, em nosso exemplo, fornecemos "capricórnio" como o valor padrão para a caixa de combinação.
No quarto exemplo, temos uma seleção dupla. Uma seleção dupla é usada quando você deseja exibir duas caixas de seleção. O valor selecionado na primeira caixa de seleção determina o que aparece na segunda caixa de seleção. Em nosso exemplo, a primeira caixa de seleção exibe "Técnico" e "Outro". Se o usuário selecionar Técnico, exibiremos TI e Hardware na segunda caixa de seleção. Caso contrário, exibiremos Contabilidade e RH. Isso é possível usando os atributos "list" e "doubleList" conforme mostrado no exemplo.
No exemplo acima, fizemos uma comparação para ver se a caixa de seleção superior é igual a Técnico. Em caso afirmativo, exibimos TI e Hardware.
Também precisamos dar um nome para a caixa superior ("nome = 'Ocupações') e a caixa inferior (nome duplo = 'ocupações2')
O Struts usa a estrutura DOJO para a implementação da tag AJAX. Em primeiro lugar, para prosseguir com este exemplo, você precisa adicionar struts2-dojo-plugin-2.2.3.jar ao seu classpath.
Você pode obter esse arquivo na pasta lib do download do struts2 (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar)
Para estes exercícios, vamos modificar HelloWorld.jsp como segue -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<%@ taglib prefix = "sx" uri = "/struts-dojo-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
<sx:head />
</head>
<body>
<s:form>
<sx:autocompleter label = "Favourite Colour"
list = "{'red','green','blue'}" />
<br />
<sx:datetimepicker name = "deliverydate" label = "Delivery Date"
displayformat = "dd/MM/yyyy" />
<br />
<s:url id = "url" value = "/hello.action" />
<sx:div href="%{#url}" delay="2000">
Initial Content
</sx:div>
<br/>
<sx:tabbedpanel id = "tabContainer">
<sx:div label = "Tab 1">Tab 1</sx:div>
<sx:div label = "Tab 2">Tab 2</sx:div>
</sx:tabbedpanel>
</s:form>
</body>
</html>Quando executamos o exemplo acima, obtemos a seguinte saída -
Vamos agora examinar este exemplo uma etapa de cada vez.
A primeira coisa a notar é a adição de uma nova biblioteca de tags com o prefixo sx. Esta (struts-dojo-tags) é a biblioteca de tags criada especificamente para a integração ajax.
Então, dentro do cabeçalho HTML, chamamos sx: head. Isso inicializa a estrutura do dojo e a torna pronta para todas as invocações AJAX na página. Esta etapa é importante - suas chamadas ajax não funcionarão sem o sx: head sendo inicializado.
Primeiro, temos a tag autocompleter. A tag autocompleter se parece muito com uma caixa de seleção. Ele é preenchido com os valores vermelho, verde e azul. Mas a diferença entre uma caixa de seleção e esta é que ela se completa automaticamente. Ou seja, se você começar a digitar gr, será preenchido com "verde". Fora isso, essa tag é muito semelhante à tag s: select que abordamos anteriormente.
Em seguida, temos um selecionador de data e hora. Esta tag cria um campo de entrada com um botão próximo a ele. Quando o botão é pressionado, um seletor de data e hora pop-up é exibido. Quando o usuário seleciona uma data, a data é preenchida no texto de entrada no formato que é especificado no atributo de tag. Em nosso exemplo, especificamos dd / MM / aaaa como o formato da data.
Em seguida, criamos uma tag url para o arquivo system.action que criamos nos exercícios anteriores. Não precisa ser o system.action - pode ser qualquer arquivo de ação criado anteriormente. Então temos uma div com o hiperlink definido para a url e o atraso definido para 2 segundos. O que acontece quando você executa isso é que o "Conteúdo inicial" será exibido por 2 segundos e, em seguida, o conteúdo do div será substituído pelo conteúdo dohello.action execução.
Finalmente, temos um painel de guias simples com duas guias. As guias são divs também com os rótulos Guia 1 e Guia2.
É importante notar que a integração da tag AJAX no Struts ainda é um trabalho em andamento e a maturidade dessa integração aumenta lentamente a cada lançamento.
Spring é uma estrutura da web popular que fornece integração fácil com muitas tarefas comuns da web. Portanto, a questão é: por que precisamos do Spring quando temos o Struts2? Bem, Spring é mais do que um framework MVC - ele oferece muitos outros recursos que não estão disponíveis no Struts.
Por exemplo: injeção de dependência que pode ser útil para qualquer framework. Neste capítulo, examinaremos um exemplo simples para ver como integrar Spring e Struts2 juntos.
Em primeiro lugar, você precisa adicionar os seguintes arquivos ao caminho de construção do projeto a partir da instalação do Spring. Você pode baixar e instalar a versão mais recente do Spring Framework emhttps://www.springsource.org/download
- org.springframework.asm-x.y.z.M(a).jar
- org.springframework.beans-x.y.z.M(a).jar
- org.springframework.context-x.y.z.M(a).jar
- org.springframework.core-x.y.z.M(a).jar
- org.springframework.expression-x.y.z.M(a).jar
- org.springframework.web-x.y.z.M(a).jar
- org.springframework.web.servlet-x.y.z.M(a).jar
Finalmente adicione struts2-spring-plugin-x.y.z.jar na tua WEB-INF/libdo diretório lib do struts. Se você estiver usando o Eclipse, poderá enfrentar uma exceção java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .
Para resolver este problema, você deve entrar Markere clique com o botão direito nas dependências da classe uma por uma e faça Quick fix para publicar / exportar todas as dependências. Por fim, certifique-se de que não haja conflito de dependência disponível na guia do marcador.
Agora vamos configurar o web.xml para a integração Struts-Spring da seguinte forma -
<?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>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<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>
</web-app>O importante a observar aqui é o ouvinte que configuramos. oContextLoaderListeneré necessário para carregar o arquivo de contexto do spring. O arquivo de configuração do Spring é chamadoapplicationContext.xml arquivo e deve ser colocado no mesmo nível que o web.xml Arquivo
Vamos criar uma classe de ação simples chamada User.java com duas propriedades - firstName e lastName.
package com.tutorialspoint.struts2;
public class User {
private String firstName;
private String lastName;
public String execute() {
return "success";
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}Agora vamos criar o applicationContext.xml arquivo de configuração do spring e instanciar o User.javaclasse. Conforme mencionado anteriormente, este arquivo deve estar na pasta WEB-INF -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id = "userClass" class = "com.tutorialspoint.struts2.User">
<property name = "firstName" value = "Michael" />
<property name = "lastName" value = "Jackson" />
</bean>
</beans>Como visto acima, configuramos o bean do usuário e injetamos os valores Michael e Jacksonno feijão. Também demos a este bean um nome "userClass", para que possamos reutilizá-lo em outro lugar. Em seguida, vamos criar oUser.jsp na pasta WebContent -
<%@ 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 From Struts2 - Spring integration</h1>
<s:form>
<s:textfield name = "firstName" label = "First Name"/><br/>
<s:textfield name = "lastName" label = "Last Name"/><br/>
</s:form>
</body>
</html>o User.jsparquivo é bastante simples. Ele tem apenas um propósito - exibir os valores do nome e do sobrenome do objeto de usuário. Finalmente, vamos colocar todas as entidades juntas usando ostruts.xml Arquivo.
<?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.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "user" class="userClass"
method = "execute">
<result name = "success">/User.jsp</result>
</action>
</package>
</struts>O importante a notar é que estamos usando o id userClasspara se referir à classe. Isso significa que estamos usando spring para fazer a injeção de dependência para a classe User.
Agora clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/User.jsp. Isso produzirá a seguinte tela -
Agora vimos como reunir duas grandes estruturas. Isso conclui o capítulo de integração Struts - Spring.
Neste capítulo, vamos percorrer as etapas envolvidas na integração da estrutura do Tiles com o Struts2. Apache Tiles é uma estrutura de modelos construída para simplificar o desenvolvimento de interfaces de usuário de aplicativos da web.
Em primeiro lugar, precisamos baixar os arquivos jar dos tiles do site do Apache Tiles . Você precisa adicionar os seguintes arquivos jar ao caminho de classe do projeto.
- tiles-api-x.y.z.jar
- tiles-compat-x.y.z.jar
- tiles-core-x.y.z.jar
- tiles-jsp-x.y.z.jar
- tiles-servlet-x.y.z.jar
Além do acima, temos que copiar os seguintes arquivos jar do download do struts2 em seu WEB-INF/lib.
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
Agora vamos configurar o web.xmlpara a integração Struts-Tiles conforme fornecido abaixo. Há dois pontos importantes a serem observados aqui. Primeiro, precisamos dizer aos tiles, onde encontrar o arquivo de configuração de tilestiles.xml. No nosso caso, será sob/WEB-INFpasta. Em seguida, precisamos inicializar o listener do Tiles que vem com o download do Struts2.
<?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_2_5.xsd"
id = "WebApp_ID" version = "2.5">
<display-name>Struts2Example15</display-name>
<context-param>
<param-name>
org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG
</param-name>
<param-value>
/WEB-INF/tiles.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.apache.struts2.tiles.StrutsTilesListener
</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>Em seguida, vamos criar tiles.xml na pasta / WEB-INF com o seguinte conteúdo -
<?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 = "Template"/>
<put-attribute name = "banner" value = "/banner.jsp"/>
<put-attribute name = "menu" value = "/menu.jsp"/>
<put-attribute name = "body" value = "/body.jsp"/>
<put-attribute name = "footer" value = "/footer.jsp"/>
</definition>
<definition name = "tiger" extends = "baseLayout">
<put-attribute name = "title" value = "Tiger"/>
<put-attribute name = "body" value = "/tiger.jsp"/>
</definition>
<definition name = "lion" extends = "baseLayout">
<put-attribute name = "title" value = "Lion"/>
<put-attribute name = "body" value = "/lion.jsp"/>
</definition>
</tiles-definitions>Em seguida, definimos um layout de esqueleto básico no baseLayout.jsp. Possui cinco áreas reutilizáveis / substituíveis. Nomeadamentetitle, banner, menu, body e footer. Fornecemos os valores padrão para o baseLayout e, em seguida, criamos duas personalizações que se estendem do layout padrão. O layout do tigre é semelhante ao layout básico, exceto que usa otiger.jspcomo corpo e o texto "Tigre" como título. Da mesma forma, o layout do leão é semelhante ao layout básico, exceto que usa olion.jsp como seu corpo e o texto "Lion" como o título.
Vamos dar uma olhada nos arquivos jsp individuais. A seguir está o conteúdo debaseLayout.jsp arquivo -
<%@ 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>
<tiles:insertAttribute name = "banner" /><br/>
<hr/>
<tiles:insertAttribute name = "menu" /><br/>
<hr/>
<tiles:insertAttribute name = "body" /><br/>
<hr/>
<tiles:insertAttribute name = "footer" /><br/>
</body>
</html>Aqui, acabamos de montar uma página HTML básica que contém os atributos de tiles. Nós inserimos os atributos dos tiles nos lugares onde precisamos que eles estejam. A seguir, vamos criar umbanner.jsp arquivo com o seguinte conteúdo -
<img src="http://www.tutorialspoint.com/images/tp-logo.gif"/>o menu.jsp arquivo terá as seguintes linhas que são os links - para as ações dos struts TigerMenu.action e LionMenu.action.
<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>o lion.jsp o arquivo terá o seguinte conteúdo -
<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The liono tiger.jsp o arquivo terá o seguinte conteúdo -
<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tigerA seguir, vamos criar o arquivo de classe de ação MenuAction.java que contém o seguinte -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}Esta é uma aula bastante direta. Declaramos dois métodos tiger () e lion () que retornam tigre e leão como resultados, respectivamente. Vamos colocar tudo junto nostruts.xml arquivo -
<!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">
<result-types>
<result-type name = "tiles"
class="org.apache.struts2.views.tiles.TilesResult" />
</result-types>
<action name = "*Menu" method = "{1}"
class = "com.tutorialspoint.struts2.MenuAction">
<result name = "tiger" type = "tiles">tiger</result>
<result name = "lion" type = "tiles">lion</result>
</action>
</package>
</struts>Vamos verificar o que fizemos no arquivo acima. Em primeiro lugar, declaramos um novo tipo de resultado denominado "blocos", pois agora estamos usando blocos em vez de jsp simples para a tecnologia de visualização. Struts2 tem suporte para o tipo de resultado Visualização de blocos, então criamos o tipo de resultado "blocos" para ser da classe "org.apache.struts2.view.tiles.TilesResult".
A seguir, queremos dizer se a solicitação é para /tigerMenu.action levar o usuário para a página de blocos do tigre e se a solicitação é para /lionMenu.action levar o usuário para a página de blocos do leão.
Conseguimos isso usando um pouco de expressão regular. Em nossa definição de ação, dizemos que qualquer coisa que corresponda ao padrão "* Menu" será tratada por esta ação. O método de correspondência será chamado na classe MenuAction. Ou seja, tigerMenu.action invocará tiger () e lionMenu.action invocará lion (). Em seguida, precisamos mapear o resultado do resultado para as páginas de blocos apropriadas.
Agora clique com o botão direito no nome do projeto e clique Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/tigerMenu.jsp. Isso produzirá a seguinte tela -
Da mesma forma, se você acessar a página lionMenu.action, verá a página lion que usa o mesmo layout de blocos.
O Hibernate é um serviço de consulta e persistência Objeto / Relacional de alto desempenho licenciado sob a licença GNU Lesser General Public License (LGPL) e é gratuito para download. Neste capítulo. vamos aprender como obter a integração do Struts 2 com o Hibernate. Se você não está familiarizado com o Hibernate, pode verificar nosso tutorial do Hibernate .
Configuração de banco de dados
Para este tutorial, vou usar o banco de dados MySQL "struts2_tutorial". Eu me conecto a este banco de dados na minha máquina usando o nome de usuário "root" e sem senha. Em primeiro lugar, você precisa executar o seguinte script. Este script cria uma nova tabela chamadastudent e cria poucos registros nesta tabela -
CREATE TABLE IF NOT EXISTS `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`first_name` varchar(40) NOT NULL,
`last_name` varchar(40) NOT NULL,
`marks` int(11) NOT NULL,
PRIMARY KEY (`id`)
);
--
-- Dumping data for table `student`
--
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(3, 'Jessica', 'Drake', 21);Configuração do Hibernate
Em seguida, vamos criar o hibernate.cfg.xml, que é o arquivo de configuração do hibernate.
<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.connection.driver_class">c
om.mysql.jdbc.Driver
</property>
<property name = "hibernate.connection.url">
jdbc:mysql://www.tutorialspoint.com/struts_tutorial
</property>
<property name = "hibernate.connection.username">root</property>
<property name = "hibernate.connection.password"></property>
<property name = "hibernate.connection.pool_size">10</property>
<property name = "show_sql">true</property>
<property name = "dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.hbm2ddl.auto">update</property>
<mapping class = "com.tutorialspoint.hibernate.Student" />
</session-factory>
</hibernate-configuration>Vamos examinar o arquivo de configuração de hibernação. Primeiro, declaramos que estamos usando o driver MySQL. Em seguida, declaramos o url jdbc para conexão com o banco de dados. Em seguida, declaramos o nome de usuário, a senha e o tamanho do pool da conexão. Também indicamos que gostaríamos de ver o SQL no arquivo de log ativando "show_sql" para true. Siga o tutorial de hibernação para entender o que essas propriedades significam.
Finalmente, definimos a classe de mapeamento como com.tutorialspoint.hibernate.Student que criaremos neste capítulo.
Configuração de ambiente
Em seguida, você precisa de muitos frascos para este projeto. Em anexo está uma captura de tela da lista completa de arquivos JAR necessários -
A maioria dos arquivos JAR pode ser obtida como parte da distribuição do struts. Se você tiver um servidor de aplicativos como glassfish, websphere ou jboss instalado, poderá obter a maioria dos arquivos jar restantes da pasta lib do appserver. Caso contrário, você pode baixar os arquivos individualmente -
Arquivos jar do Hibernate - Hibernate.org
Plugin de hibernação do Struts - plugin de hibernação do Struts
Arquivos JTA - arquivos JTA
Arquivos Dom4j - Dom4j
arquivos log4j - log4j
O restante dos arquivos, você deve conseguir obter na distribuição do Struts2.
Classes de Hibernate
Vamos agora criar as classes java necessárias para a integração do hibernate. A seguir está o conteúdo deStudent.java -
package com.tutorialspoint.hibernate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "student")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name = "last_name")
private String lastName;
@Column(name = "first_name")
private String firstName;
private int marks;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
}Esta é uma classe POJO que representa o studenttabela de acordo com a especificação do Hibernate. Possui as propriedades id, firstName e lastName que correspondem aos nomes das colunas da tabela do aluno. Em seguida, vamos criarStudentDAO.java arquivo da seguinte forma -
package com.tutorialspoint.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.TransactionTarget;
public class StudentDAO {
@SessionTarget
Session session;
@TransactionTarget
Transaction transaction;
@SuppressWarnings("unchecked")
public List<Student> getStudents() {
List<Student> students = new ArrayList<Student>();
try {
students = session.createQuery("from Student").list();
} catch(Exception e) {
e.printStackTrace();
}
return students;
}
public void addStudent(Student student) {
session.save(student);
}
}A classe StudentDAO é a camada de acesso aos dados da classe Student. Ele contém métodos para listar todos os alunos e, em seguida, salvar um novo registro do aluno.
Classe de Ação
Arquivo seguinte AddStudentAction.javadefine nossa classe de ação. Temos dois métodos de ação aqui - execute () e listStudents (). O método execute () é usado para adicionar o novo registro do aluno. Usamos o método save () do dao para fazer isso.
O outro método, listStudents (), é usado para listar os alunos. Usamos o método list dao para obter a lista de todos os alunos.
package com.tutorialspoint.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.hibernate.StudentDAO;
public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {
Student student = new Student();
List<Student> students = new ArrayList<Student>();
StudentDAO dao = new StudentDAO();
@Override
public Student getModel() {
return student;
}
public String execute() {
dao.addStudent(student);
return "success";
}
public String listStudents() {
students = dao.getStudents();
return "success";
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}Você notará que estamos implementando a interface ModelDriven. Isso é usado quando sua classe de ação está lidando com uma classe de modelo concreto (como Student), em oposição a propriedades individuais (como firstName, lastName). A interface ModelAware requer que você implemente um método para retornar o modelo. Em nosso caso, estamos retornando o objeto "aluno".
Criar arquivos de visualização
Vamos agora criar o student.jsp visualizar arquivo com o seguinte conteúdo -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "addStudent">
<s:textfield name = "firstName" label = "First Name"/>
<s:textfield name = "lastName" label = "Last Name"/>
<s:textfield name = "marks" label = "Marks"/>
<s:submit/>
<hr/>
<table>
<tr>
<td>First Name</td>
<td>Last Name</td>
<td>Marks</td>
</tr>
<s:iterator value = "students">
<tr>
<td><s:property value = "firstName"/></td>
<td><s:property value = "lastName"/></td>
<td><s:property value = "marks"/></td>
</tr>
</s:iterator>
</table>
</s:form>
</body>
</html>O student.jsp é bastante direto. Na seção superior, temos um formulário enviado para "addStudent.action". Recebe firstName, lastName e marks. Como a ação addStudent está ligada ao ModelAware "AddSudentAction", automaticamente um bean de aluno será criado com os valores de firstName, lastName e marcas preenchidas automaticamente.
Na seção inferior, examinamos a lista de alunos (consulte AddStudentAction.java). Nós iteramos pela lista e exibimos os valores de nome, sobrenome e marcas em uma tabela.
Configuração Struts
Vamos juntar tudo usando 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.devMode" value = "true" />
<package name = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success">/students.jsp</result>
</action>
</package>
</struts>O importante a notar aqui é que nosso pacote "myhibernate" estende o pacote padrão struts2 chamado "hibernate-default". Em seguida, declaramos duas ações - addStudent e listStudents. addStudent chama execute () na classe AddStudentAction e, em caso de sucesso, chama o método de ação listStudents.
O método de ação listStudent chama listStudents () na classe AddStudentAction e usa student.jsp como visualização.
Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Isso produzirá a seguinte tela -
Na seção superior, obtemos um formulário para inserir os valores de um novo registro de aluno e a seção inferior lista os alunos no banco de dados. Vá em frente e adicione um novo registro do aluno e pressione enviar. A tela será atualizada e mostrará uma lista atualizada sempre que você clicar em Enviar.