Avaliação do Framework Struts para Implementação de Aplicações

Universidade Federal de Santa Catarina
Departamento de Informática e Estatística
INE5631 – Projetos I
Gisele Floriano Pereira - 02238586
Resumo do Trabalho de Conclusão de Curso:
Avaliação do Framework Struts para Implementação de Aplicações Web
usando Padrão Modelo-Visão-Controlador
Por Alice Alves Corrêa
O trabalho resumido neste documento teve como objetivo principal, analisar os
aspectos específicos do Framework Struts e apresentar a implementação de um sistema de
notas fiscais utilizando este framework, juntamente com a arquitetura Modelo-VisãoControlador.
Na introdução é feita uma análise sobre a evolução dos sistemas e/ou páginas Web.
Fala de como o usuário passou de simplesmente um ente que navega pelo site para um
papel passivo na visualização e comportamento dos sistemas. Neste contexto, a autora cita
as tecnologias que foram utilizadas no surgimento da Web, mas que se tornaram
ineficientes ou não atendiam a todas as necessidades dos novos paradigmas de
desenvolvimento de sistemas. Entre essas tecnologias, estão a linguagem C e o Perl. Para
suprir as necessidades deixadas por essas tecnologias, surgiram então o Php e o JSP.
Mesmo atendendo às novas necessidades, JSP por exemplo quando utilizado, é dificil de
manter e reutilizar, por misturar no código tanto a parte gráfica, quanto a parte lógica do
sistema.
Surge então o Struts, que é um framework para sanar essas dificuldades e contruir
aplicações reusáveis e fáceis de manter. Sua intenção era a de separas as camadas de um
sistema, em camada de apresentação, lógica e de negócios. Esse framework foi
implementado em Java baseando-se nos padrões MVC - Modelo - Visão - Controlador.
Dentre os principais objetivos a serem alcançados com esse trabalho, pode-se citar:
 A avaliação do Struts para implementação de aplição Web no padrão MVC,
conhecendo seus componentes e suas formas de utilização.
 Avaliação dos requisitos para o desenvolvimento, a complexidade e limitações do
Struts.
Como justificativa para o desenvolvimento deste trabalho, a autora cita grandes portais
e suas dificuldades em manter tais sistemas, devido ao alto custo de desenvolvimento,
operação e atualização destes sites. O Struts seria, então, uma forma de reduzir estes custos
das empresas que planejam ter ou tenham um sistema, aumentando assim a sua renda e
tendo possibilidades de gerar novos empregos.
Além disso, outras justificativas utilizadas foram:
- o fato do Struts ter código livre e sem custos;
- A facilidade da internacionalização do sistema;
- a possibilidade de divisão de trabalho entre programadores e designers.
No capítulo dois, são apresentadas as principais tecnologias destinadas ao
desenvolvimento de aplicações Web.
- CGI - Common Gateway Interface: surgiu com o propósito de permitir que os servidores
interagissem com aplicações externas de uma maneira pela qual as páginas de hipertexto
não tivessem mais que ser exclusivamente estáticas. Essa é sua principal vantagem, porém
possuim limitações em sua implementação. O tempo de resposta, por exemplo, apresentado
por aplicações que utilizam esta tecnologia, pode ser imenso, dependendo da quantidade de
usuários que estejam fazendo requisições ao mesmo tempo. Outra desvantagem é o fato
deste estar rodando em um processo separado no servidor Web, o que dificulta a
manipulação do fluxo de informações, autorizações e autenticação de usuários.
- Tecnologias de Páginas de Servidor: criadas com o intuito de permitir criação de
páginas fáceis de manter principalmente por não-programadores. Algumas tecnologias
como ASP, PHP, templates Velocity e JSP são exemplos desta categoria. Suas principais
vantagens são:
- A página do servidor não é um arquivo de programa compilado na aplicação básica.
- A sintaxe da página do servidor lembra uma página HTML convencional.
- O atendimento de cada resquisição não implica na criação de um novo processo no
sistema operacional.
- Plataforma J2EE: Plataforma para executar aplicações Java do lado do servidor. Foi
responsável pela padronização das APIs e pela diminuição do tempo de aprendizado para
aplicações Java para servidores. São definidos dois tipo de contêineres para o
gerenciamento do ciclo de vida de componente no servidor: os servlets e os Enterprise Java
Beans, ou EJB.
Servlets surgiram como uma alternativa eficiente para aplicações CGI. Oferecem
mecanismos adequados a qualquer servidor baseado em requisições e respostas. Seu ciclo
de vida possui 4 etapas: o cliente emite uma requisição ao servidor; o servidor chama o
Servlet para que efetue a execução do serviço solicitado; o Servlet gera conteúdo dinâmico,
respondendo á solicitação do cliente, podendo usar recursos disponíveis na plataforma Java;
o Servidor retorna o resultado gerado para o cliente como uma resposta http.
O Servlet tem ainda a vantagem de permitir a utilização de toda a plataforma
baseada em Java, incluindo a vantagem da sua portabilidade.
Java Server Pages é uma especificação que combina Java e HTML para prover
conteúdo dinâmico em páginas Web. JSPs são mais convenientes de se escrever porque
permitem que o código seja inserido diretamente em páginas HTML, em contraste com os
servlets, nos quais todo o conteúdo em HTML precisa ser gerado a partir do código Java.
A primeira vez que o arquivo é requisitado, ele é traduzido em um Servlet e
compilado em um objeto que é carregado na memória. O servlet gerado atende a requisição
e a saída é enviada ao cliente requisitante. Em todas as requisições seguintes o servidor irá
averiguar se o código fonte da página mudou. Caso o código não tenha mudado, o servidor
chama o objeto Java que já está compilado. Se o código fonte foi alterado, o contêiner irá
recompilar novamente a página.
As JSPs fornecem duas abordagens distintas para a inserção do código que será
usado no servidor:
-
-
scriptlets: códigos Java colocados diretamente na página. Os scriptlets são
relativamente fáceis de usar, rápidos e poderosos, porém sua manutenção e
atualização são trabalhosas.
Tags JSP Customizadas: tem sintaxe e formato parecido com as tags HTML; elas
requerem um pouco mais esforço para serem escritas, entretanto são muito mais
fáceis de usar e manter em longo prazo.
Na seção 2.3.2.2, é feita uma comparação do JSP com outras tecnologias, onde suas
vantagens são descritas sobre cada uma. A conclusão é que JSP possui vantagens sobre
todas as suas tecnologias concorrentes.
Padrões de Projeto
Padrões de projeto são soluções já testadas que se mostraram eficientes para
resolver problemas recorrentes e que devem serseguidas para resolução destes problemas.
Esses padrões são identificados e reutilizados, inclusive em desenvolvimento de Software.
Os padrões servem como um guia no desenvolvimento de novas aplicações. Eles mostram
qual a melhor maneira para se implementar a aplicação, após definição de características e
requisitos do sistema.
Neste contexto, o padrão MVC viabiliza uma maneira eficiente de projetar sistemas
de software interativos. Sua idéia central é separar as interfaces dos dados representados. A
utilização do padrão MVC torna as aplicações mais fáceis de serem desenvolvidas e
mantidas, caso as seguintes características estejam presentes:
a aparência possa ser mudada sem afetar as estruturas de dados e lógica do negócio
e a aplicação deve manter diferentes interfaces, como linguagens diversas ou diferentes
níveis permissão de usuário.
Alguns modelos de implementação de aplicações utilizando jsp são descritos pela
autora.
Modelo 1: maneira mais fácil de desenvolver aplicações baseadas em JSP. Nesse modelo,
ao clicar em um link, uma página JSP é chamada diretamente. O Código JSP contém
código embutido para acessar os Java Beans do Modelo. O Java Beans do Modelo contém
atributos para capturar os parâmetros passados pela requisição. Além disso ele contém
lógica de negócios para acessar os dados necessários para a página. A página JSP é então
mostrada em HTML usando Java Beans, podendo usar também classes auxiliares e outras
tags. Este modelo é indicado para aplicações de pequeno porte, pois há muitos scriptlets
embutidos no JSP.
Modelo 2 – MVC: A principal diferença entre o Modelo 1 e o Modelo 2 é que no segundo,
um controlador gerencia as requisições de um usuário, ao invés da própria página JSP. O
controlador é implementado como um servlet. Neste modelo praticamente não existem
scriptlets, mas eles ainda precisam ser usados nesse modelo. Porém em comparação com o
modelo 1, esta é bem mais fácil de se manter e reusar.
O Framework Struts
Neste capítulo, é definido o que é um Framework e é feito um estudo detalhado
sobre o Struts. O Struts, criado em 2000, foi construído utilizando tecnologias J2EE, porém
não é parte do padrão J2EE. Assim, ele é um padrão complementar ao J2EE. O Struts é
uma implementação do lado do servidor do MVC usando uma combinação de JSP, JSP tags
e Servlets Java. Este framework possui este nome em referência às estruturas da engenharia
civil, que é o que dá sustentação às construções. Essa analogia ilustra bem a função de
Struts em uma aplicação, pois o Struts serve para dar sustentação a cada camada de uma
aplicação.
Struts é muito útil na internacionalização de sistemas, pois permite que um sistema
construído com este framework use rótulos e mensagens em arquivos separados. Quando
uma mensagem ou rótulo precisa ser escrito, a aplicação pode se referir à mensagem
através de sua chave. O Framework recupera o texto para o rótulo durante a execução. O
nome e localização de arquivos de imagens também podem ser lidos a partir de um pacote
de recursos.
O Modelo é comumente chamado de camada de negócios. O modelo representa os
dados da lógica de negócios e deveria assemelhar-se com as entidades no mundo real e
processos para a organização. A camada do modelo esconde os detalhes da implementação,
o que facilita o gerenciamento de alterações.
O termo ‘modelo’ tem vários significados diferentes. Em termos gerais, um modelo
é uma representação de um aspecto da realidade. O principal propósito de criar um modelo
é ajudar a entender, descrever, e simular como as coisas funcionam no mundo real.
Tipos de modelo:
-
Modelo Conceitual: O Modelo conceitual é desenvolvido de um conjunto de casos
de uso para o sistema. O propósito de construir o modelo é ajudar a identificar as
entidades que mais facilmente serão classes no estágio de projeto e ajudar a
entender melhor o problema do domínio. Durante a análise do domínio do
problema, o modelo conceitual deve ser desenvolvido baseado em entidades do
mundo real dentro do espaço do problema. O modelo conceitual ilustra os conceitos,
os relacionamentos e os atributos que pertencem a cada conceito. O comportamento
atualmente não é representado nesse tipo de modelo.
-
Persistência: são dados que devem ser armazenados de forma a poderem ser
recuperados depois. Esses dados podem ser armazenados em banco de dados,
representando de forma plana os dados e seus relacionamentos.
A seguir, serão listados os principais componentes do Struts, citado no Trabalho de
Conclusão de Curso aqui resumido.
A Visão
Uma visão corresponde a uma representação do modelo do domínio em uma
interface com o usuário. Existem muitas visões diferentes do mesmo modelo.
Metaforicamente falando, a visão é uma janela que clientes podem usar para olhar o estado
do modelo, e a perspectiva pode ser diferente dependendo em qual janela um cliente
observa.
Uma visão corresponde a uma representação do modelo do domínio em uma
interface com o usuário. A visão dentro da camada web do MVC tipicamente consiste em
páginas HTML e JSP, que são usadas para prover conteúdo estático, enquanto JSPs podem
ser usados para conteúdo tanto estático quanto dinâmico.
Action Forms: A Classe ActionForm é usada para capturar entradas de dados de
formulários HTML e transferir estes dados para a classe Action. A classe ActionForm age
como um buffer para armazenar o estado dos dados que o usuário entrou enquanto estava
sendo validado.
DynaActionForm: Na versão 1.0 do Struts, era necessário que cada formulário nas páginas
fosse associado a uma ActionForm. A versão 1.1 mudou isso com a introdução da
subclasse DynaActionForm, que seria o ActionForm dinâmico. Um ActionForm
convencional é desenvolvido em Java e declarado no arquivo de configuração do Struts
enquanto a DynaActionForm não tem uma classe
Java associada.
Bibliotecas de Tags: As Bibliotecas de tags Struts fornecem a maior parte das
funcionalidades que as aplicações precisam para criar uma apresentação seguindo o padrão
MVC.
Java Server Pages Standard Tag Library (JSTL): Como uma alternativa para as tags
JSP, a Java Server Pages Standard Tag Library (JSTL) apresenta um conjunto de tags que
podem se sobrepor às tags do struts. Rapidamente podemos esperar que os contêineres
sejam otimizados para o uso de JSTL, tonando-a a biblioteca de tags escolhida para a maior
parte das aplicações. JSTL não dispensa a necessidade de tags personalizadas.
O Controlador: O Controlador é um Servlet Java, cujos componentes são responsáveis
por detectar as entradas do usuário, possivelmente alterar o domínio do problema, e
selecionar a próxima visão para o cliente. O Controlador ajuda a separar a apresentação do
modelo. Essa separação nos dá muito mais liberdade para desenvolver uma grande
variedade de apresentações baseadas em um único modelo. O uso do controlador provê um
ponto centralizado de controle onde todas as requisições dos clientes são inicialmente
processadas. O controle centralizado efetua duas requisições do MVC. Primeiro o
controlador age como o mediador/tradutor entre as entradas e o modelo, provendo uma
funcionalidade comum, como segurança, login e outros serviços importantes por trás de
cada requisição do cliente. Segundo, a visão é desacoplada da lógica de negócios e de
outros componentes de visão, uma vez que todas as requisições são filtradas através do
controlador. Isso faz com que as aplicações se tornem muito mais flexíveis
Classe Action: Esta classe é a parte central do Struts. Ela é a ligação entre a requisição de
um cliente e a lógica dos negócios. Cada classe Action é destinada tipicamente para efetuar
uma única operação de negócios do interesse do cliente. Uma única operação de negócios
não significa que a Action não possa efetuar somente uma tarefa. Ao invés disso, a tarefa
que ele efetua deve ser coesa e centrada em uma única unidade funcional. Em outras
palavras, as tarefas efetuadas pela Action devem ser relacionadas a uma operação de
negócios. Não deveria ser criado uma Action com funcionalidades de cesta de compras e
responsabilidade de login e logout juntos, por exemplo. Essas áreas da aplicação não são
fortemente relacionadas e não devem ser associadas.
DispatchAction: Como cada classe Action é destinada tipicamente para efetuar uma única
operação de negócios do interesse do cliente, seria necessário criar uma classe Action para
cada operação. Essa abordagem é valida, entretanto não é adequada, uma vez que pode
existir duplicidade de código entre essas Actions. Assim a DispatchAction provê
mecanismos para simplificar a execução de múltiplas operações, chamando-as pelo nome
do método específico ao invés de sobrescrevermos o método execute(). Para tanto é
necessário especificar no arquivo de configuração do struts o nome do parâmetro que irá
apontar para o nome do método a ser utilizado.
A Classe ActionForward: O método execute() retorna a próxima visão a ser mostrada. A
ActionForward é a classe que encapsula a informação sobre a próxima visão a ser
apresentada. O Struts estimula não colocar o nome da página JSP apontando diretamente
para a próxima visão, mas sim usar um nome lógico. Essa associação entre o nome lógico e
a página JSP física é encapsulada na instância ActionForward retornada do método
execute().
Configuração de uma Aplicação: Em Struts é necessário configurar adequadamente o
arquivo web.xml. O passo mais importante é configurar o ActionServlet, que receberá todas
as requisições para a aplicação. Ainda, é preciso configurar o arquivo struts-config.xml.
Depois de definir o servlet, precisamos definir que tipo de URL o servlet irá interceptar. O
ideal é definir padrões que sejam caminhos ou sufixos. No bloco de recursos é criada uma
referência para um recurso criado previamente, como por exemplo mecanismos de
conectividade com um banco de dados JDBC (Java Database Connectivity).
Arquivo de Configuração do Struts: O Arquivo de configuração do struts é do tipo XML,
geralmente chamado de struts-config.xml, e segue as regras estabelecidas em uma DTD
(Document Type Definition) correspondente a sua versão, que mostra todos os elementos
possíveis dentro de um arquivo de configuração. os cinco elementos mais importantes e os
seus atributos mais relevantes são:
1 - Seção de definição de Form Beans.
2 - Seção de definição de Global Forwards.
3 - Seção de definição de Action Mappings.
4 - Seção de definição do Controlador.
5 - Seção de definição do Recurso de Mensagens.
Tratamento de Exceções: O Tratamento de Exceções é uma parte crucial no
desenvolvimento de aplicações para a Internet Na versão 1.1 do Struts foi adicionado ao
framework um pequeno, porém eficiente framework de tratamento de exceções, que
permite o tratamento declarativo e programático de erros.
Plug-ins do Struts: Um dos benefícios do Struts é a capacidade de validar dados. Caso
qualquer validação falhe, a aplicação mostra o formulário HTML novamente para que os
dados sejam corrigidos, permitindo que não seja necessário se preocupar com os
mecanismos que capturam e mostram dados inválidos.
Validações no Cliente: As validações do lado do cliente são inseguras pois é fácil enviar
uma página web e evitar qualquer script executado na página original. Assim, não podemos
contar com as validações do lado do cliente, entretanto elas podem ser úteis, uma vez que
evitam o envio imediato da página ao servidor, o que economiza tempo e largura de banda.
Sendo assim, o ideal seria validar os dados tanto no servidor quanto no cliente usando o
mesmo conjunto de regras.
Utilização do Validador: Para utilizar o validador é necessário especificar no arquivo de
configuração do struts e indicar onde estão localizados os arquivos de configuração do
validador: No struts, as validações se localizam em dois arquivos XML – o validation.xml e
o validation-rules.xml. O validation-rules.xml contém o conjunto de regras que estão
prontas para serem utilizadas. O segundo arquivo – validation.xml é especifico da
aplicação. Ele é o responsável por associar o arquivo que contém as regras com cada campo
de um form do Struts.
Tiles: O objetivo principal do Tiles é tirar o layout comum de páginas, de forma que possa
ser reusado em várias JSPs. No tiles, os layouts representam a estrutura da página como um
todo. O Layout é simplesmente uma JSP. Podemos associar essa estrutura a um molde com
encaixes. È possível colocar outras JSPs nesses encaixes de forma declarativa. Por
exemplo, podemos criar um layout com cabeçalho, corpo e rodapé. No arquivo de
configuração do tiles, determinamos quais páginas serão colocadas em cada encaixe. Em
tempo de compilação, o framework tiles compõe a página usando o layout e preenchendo
seus encaixes com cada JSP individualmente. Em essência o tiles é um framework que
permite a apresentação conjunta de páginas a partir de componentes.
-
Desenvolvimento de uma Aplicação usando Struts
No Trabalho apresentado pela autora, foi desenvolvida uma aplicação para avaliar a
adequação da utilização do Struts para desenvolvimento de uma aplicação Web. Foi
desenvolvido um projeto de uma Aplicação para Geração de notas fiscais com fluxo de
caixa, que emite notas fiscais de acordo com os dados informados pelo usuário. Houve um
processo de Análise, utilizando UML, com diagramas de Casos de Uso. Foram descritos
três casos de uso principais: gerar nota fiscal, receber pagamento e pagar conta.
Foram definidos ainda contratos para auxiliar na definição do comportamento do
sistema e definir o efeito das operações. A partir destes dados, foram definidas as
entidades, diagrama de classes, de seqüência e de estado.
A implementação ficou da seguinte forma:
Controlador: O controlador foi implementado utilizando a classe Action, que possui
apenas um método que é executado quando a página é enviada, o método execute(). O
fluxo das operações foi tratado através de comparações ou de obrigar o usuário a criar uma
classe Action para cada atividade desejada.
Visão: Para os Form Beans foi usada a classe ValidatorActionForm ao invés da classe
ActionForm, para que fosse possível utilizar o validador. A classe ValidatorForm não foi
utlizada, para não haver ma validação para cada Form Bean, que poderá ser usado por
diversas Action, mas sim efetuar a validação em cada Action em separado.
Modelo: Para a camada do modelo, que representa as entidades usadas no sistema, foi
criada uma classe que mapeia os valores obtidos diretamente do banco de dados. Existem
métodos para quatro operações básicas do banco de dados: inserir, alterar, apagar e
selecionar.
-
Resultados obtidos a partir do trabalho
Foram levantadas algumas limitações do Struts, como: Inexistência de um modelo de
eventos; Dificuldades para depuração; Apenas um ActionServlet é usado em uma
aplicação, o que pode ocasionar conflitos na configuração; É necessário o conhecimento
dos componentes do Struts para que se consiga trabalhar com ele, incluindo o
conhecimento das classes e de como elas interagem; entre outras.
Pontos fortes: O Struts é desenvolvido no modelo solicitação-resposta do protocolo HTTP,
sendo bem familiar para desenvolvedores web; Não é atrelado a nenhum a camada
particular de persistência; A configuração do Struts encapsula detalhes para uma aplicação
ou módulo; O Struts possui relativamente poucas classes básicas para que os
desenvolvedores aprendam; Bem documentado; Versões estáveis; Baseado em Padrões;
Extensível; entre outros.
-
Conclusões
Uma das maiores vantagens de se usar um framework de desenvolvimento é a
habilidade de estender e customizar as características de acordo com a necessidade da
aplicação. Ficou clara a importancia da existência de frameworks que auxiliem o
desenvolvimento de aplicações para a web e a necessidade de efetuar o desacoplamento
entre suas camadas para prover ganho no potencial de produtividade de desenvolvimento.
Para o desenvolvimento da aplicação o framework mostrou-se bastante flexível,
entretanto a maleabilidade apresentada ainda permite que sejam cometidos os mesmos erros
que originam aplicações difíceis de manter, pois apesar de existir uma separação entre
apresentação e lógica de negócios, a delimitação do modelo e da lógica pode não ser
efetuada.
É importante destacar a importância de se possuir um protótipo bem definido, que
sirva de base para o desenvolvimento, de forma que estenda os componentes do Struts para
prover as funcionalidades desejadas com a maior reutilização de código possível.
Não resta dúvida de que para projetos de sistemas mais complexos, o framework
Struts contribui consideravelmente para a melhoria da qualidade do software, auxiliando na
divisão de tarefas entre desenvolvedores e designers, facilitando a evolução do sistema e
aumentando a manutenibilidade.