3.2.2. Integração com EJB3 - Projetos

Universidade Federal de Santa Catarina – UFSC
Centro Tecnológico – CTC
Departamento de Informática e Estatística - INE
Disciplina: INE5638 – Introdução a Projetos
Um estudo de camadas de apresentação WEB
com integração com EJB
Aluno:
Thiago Roberto dos Santos
0413844-9
Orientador:
Vitório Bruno Mazzola
SUMÁRIO
SUMÁRIO ..................................................................................................................................................... 2
1. INTRODUÇÃO ..................................................................................................................................... 3
1.1. PROBLEMA ......................................................................................................................................... 3
1.2. OBJETIVOS ......................................................................................................................................... 3
1.3. JUSTIFICATIVA .................................................................................................................................... 3
2. CONCEITOS FUNDAMENTAIS ........................................................................................................ 5
2.1. JAVA ................................................................................................................................................... 5
2.2. PLATAFORMA JAVA ........................................................................................................................... 5
2.3. JAVA EE ............................................................................................................................................. 5
2.4. SERVLETS........................................................................................................................................... 5
2.5. JAVA SERVER PAGES (JSP) ............................................................................................................. 6
2.6. BIBLIOTECAS DE TAGS (TAG LIBS) ................................................................................................... 6
2.6.1.
JAVA STANTARD TAG LIBRARY (JSTL) ....................................................................................... 6
2.7. EJB .................................................................................................................................................... 7
2.8. API DE PERSISTÊNCIA JAVA (JPA) .................................................................................................. 7
2.9. EJB SESSION BEANS ........................................................................................................................ 8
2.9.1.
STATELESS SESSION BEANS......................................................................................................... 8
2.9.2.
STATEFULL SESSION BEAN ........................................................................................................... 8
2.10.
PADRÕES DE PROJETO .................................................................................................................. 8
2.11.
PADRÃO MVC ................................................................................................................................ 8
2.11.1. MODELO ......................................................................................................................................... 9
2.11.2. VISÃO ............................................................................................................................................. 9
2.11.3. CONTROLADOR .............................................................................................................................. 9
2.12.
ARQUITETURA JSP MODELO 2 ..................................................................................................... 9
2.13.
FRAMEWORK ................................................................................................................................ 10
3. METODOLOGIA E CRITÉRIOS ...................................................................................................... 11
3.1. METODOLOGIA ................................................................................................................................. 11
3.1.1.
IDENTIFICAÇÃO DE CARACTERÍSTICAS DAS FERRAMENTAS........................................................ 11
3.1.2.
ESTUDO DAS CARACTERÍSTICAS ESPECÍFICAS DAS FERRAMENTAS .......................................... 11
3.1.3.
DESENVOLVIMENTO DE UMA APLICAÇÃO .................................................................................... 11
3.2. CRITÉRIOS ........................................................................................................................................ 11
3.2.1.
VELOCIDADE DO DESENVOLVIMENTO .......................................................................................... 11
3.2.2.
INTEGRAÇÃO COM EJB3 ............................................................................................................. 12
3.2.3.
CONTROLE DE ESTADOS .............................................................................................................. 12
3.2.4.
FACILIDADE DE USO ..................................................................................................................... 12
3.2.5.
CURVA DE APRENDIZADO E DOCUMENTAÇÃO ............................................................................ 12
3.2.6.
UTILIZAÇÃO NO MERCADO ........................................................................................................... 12
4. FRAMEWORKS AVALIADOS ........................................................................................................ 14
4.1. WEBWORK .................................................................................................................................... 14
4.2. STRUTS ............................................................................................................................................. 14
4.3. SPRING ............................................................................................................................................. 14
4.4. TAPESTRY ........................................................................................................................................ 15
4.5. JBOSS SEAM.................................................................................................................................... 15
5. REFERENCIAS ................................................................................................................................. 16
1. INTRODUÇÃO
1.1. Problema
Tem se tornado cada vez mais comum a escolha do ambiente WEB para o
desenvolvimento
de
aplicações
corporativas.
Em
decorrência
disso,
a
complexidade das aplicações tem crescido muito rapidamente.
Na plataforma Java, o modelo de objetos de negócio e o mapeamento objeto
relacional vêm sendo bem atendidos pela especificação EJB3. Contudo, existe
muito trabalho repetitivo na construção de interfaces com o usuário e no
tratamento das entradas do sistema, o que prolonga o tempo de desenvolvimento
e dificulta a manutenção.
Visando facilitar o desenvolvimento da camada de apresentação, surgiram
vários frameworks para diminuir a codificação repetitiva. A grande oferta de
soluções dificulta a escolha e a identificação da mais adequada para uma
determinada aplicação ou conjunto de aplicações.
1.2. Objetivos
Este trabalho tem como principal objetivo identificar as tecnologias para
camada de apresentação mais adequadas para sistemas gerenciais de pequeno e
médio porte que utilizem a tecnologia EJB para a camada de negócio e
persistência de dados.
De maneira complementar, o trabalho também objetiva:

Identificar critérios adequados para avaliação e comparação das
tecnologias estudadas.

Identificar características comuns aos frameworks.

Elaborar um quadro comparativo dos frameworks
1.3. Justificativa
Devido ao grande número de organizações que disponibilizam serviços para
Internet e Intranet, o desenvolvimento de aplicações WEB tornou-se um ramo
muito importante na indústria de software.
A mudança de ambiente trouxe de volta uma série de problemas já
resolvidos pelas aplicações tradicionais. Várias soluções já estão disponíveis para
resolver tais problemas, mas, devido a grande oferta, é difícil escolher uma
solução perene para a organização. Até mesmo identificar quais são as opções
disponíveis e estáveis é uma tarefa complexa. Um estudo para identificação e
comparação de frameworks seria bastante útil para auxiliar as organizações
nessas tarefas.
2. CONCEITOS FUNDAMENTAIS
2.1. Java
Java é uma linguagem de programação orientada a objeto desenvolvida na
década de noventa por James Gosling, na SUN Microsystems. Java tem sintaxe
similar às linguagens C e C++. Ela é compilada em bytecodes, que podem ser
executados por uma máquina virtual ou por hardware específico.
2.2. Plataforma Java
Plataforma Java é uma plataforma para desenvolvimento e execução de
programas escritos na linguagem Java. A plataforma não é específica para um
hardware ou sistema operacional. As aplicações da plataforma rodam sobre uma
máquina virtual, que tem implementações para diversas arquiteturas. A plataforma
é distribuída em três edições diferentes:

Java Standart Edition (Java SE), para máquinas desktop.

Java Micro Edition (Java ME), para dispositivos portáteis.

Java Enterprise Edition (Java EE), para aplicações corporativas.
2.3. Java EE
Java EE é uma edição da Plataforma Java voltada para aplicações
corporativas, distribuídas, multi-camadas.
A plataforma Java EE é definida por uma especificação, considerada
informalmente um padrão, pois os fornecedores de servidores de aplicação têm
que cumprir certos requisitos para declarar seus produtos como compatíveis com
Java EE. Ela inclui várias especificações de API como JDBC, RMI, e-mail, JMS
entre outras.
2.4. Servlets
A tecnologia Java Servlet provê um simples e consistente mecanismo para
extender a funcionalidade de um servidor WEB e acessar objetos de negócio. Um
Servlet recebe uma requisição e, baseado nela, fornece uma resposta. A resposta
pode ser um documento HTML, XML, entre outros.
O contêiner WEB é responsável pelo ciclo de vida do Servlet e também pela
tradução de uma chamada http para uma requisição do Servlet.
2.5. Java Server Pages (JSP)
As JSP combinam o uso de HTML e linguagem Java. Em relação aos
Servlets, elas facilitam a divisão de trabalho entre os designers e os
programadores, pois permitem a escrita das páginas em HTML intercaladas com
código Java.
Ao serem requisitadas pela primeira vez no contêiner WEB, as JSP são
compiladas para Servlets, passando então a responder requisições de maneira
semelhante a eles.
2.6. Bibliotecas de Tags (Tag Libs)
As bibliotecas de tags definem funcionalidades que podem ser usadas em
qualquer JSP, em forma semelhante às tags HTML. As tags são processadas no
servidor no momento da requisição, podendo gerar código HTML.
As bibliotecas mantém o código mais legível, pois evitam a mistura de código
Java com código HTML. As tags costumam ser mais amigáveis também para os
designers, que não estão acostumados em ver trechos de código no meio das
páginas.
2.6.1.
Java Stantard Tag Library (JSTL)
Java Standart Tag Library encapsula em tags simples as funcionalidades
centrais comuns à maioria das aplicações WEB. Ela traz tags para iterações,
operações condicionais, manipulação de XML, tags para internacionalização e
acesso a banco de dados via SQL.
2.7. EJB
EJB é sigla de Enterprise Java Beans, especificação de um componente
para
construção
modular
de
aplicações.
A
especificação
padroniza
a
implementação da regra de negócio das aplicações.
EJB especifica como um servidor de aplicação prove:

Persistência de Dados

Processamento de transações/Controle de Concorrência

Segurança

Serviço de troca de mensagens (JMS)

Invocação remota de procedimentos (RMI/IIOP)

Disponibilização de Métodos de Negócio como Web Services
2.8. API de Persistência Java (JPA)
A API de Persistência Java (JPA) provê mapeamento objeto relacional para
JAVA. O mapeamento facilita o desenvolvimento de aplicações orientadas a
objeto com dados persistidos em bancos de dados relacionais.
2.8.1.
Entidades
Entidades são classes Java que, tipicamente, representam uma tabela uma
base de dados relacional. Cada instância da classe, por sua vez, representa uma
linha na tabela. As entidades podem se relacionar entre si nas multiplicidades um
para um (One-to-One), um para muitos (One-to-Many), muitos para um (Many-toOne) e muitos para muitos (Many-to-Many).
O mapeamento entre as tabela e as entidades é feita através de simples
anotações. As anotações permitem o mapeamento das relações e os ajustes de
nome da tabela e das colunas.
2.8.2.
Java Persistence Query Language
Java Persistence Query Language é uma linguagem semelhante a SQL, mas
pode ser feita contra as entidades mapeadas. Dessa forma é possível abstrair a
forma de armazenamento dos dados.
2.9. EJB Session Beans
Session Beans são tipicamente classes de negócio que podem ser
publicadas em um contêiner J2EE.
2.9.1.
Stateless Session Beans
Stateless Session Beans não mantém estado entre as requisições, podendo
ser acessado por diversos clientes diferentes.
2.9.2.
Statefull Session Bean
Statefull Session Bean mantém o estado entre as requisições do cliente.
Dessa forma, cada instância atende apenas um cliente por vez.
2.10. Padrões de projeto
Os padrões de projeto são soluções já testadas para resolver problemas
recorrentes. Os padrões são documentados e, a medida que se mostrem
eficientes, devem ser reutilizados. Os padrões de projeto precisam ser adaptados
ao contexto da aplicação. Eles não se propõem a determinar a maneira como o
código deve ser escrito, mas como os elementos estão estruturados.
2.11. Padrão MVC
O padrão MVC teve origem no SmallTalk, onde era usado para separar a
interface com o usuário dos dados. Dessa forma, mudanças as mudanças de
interface causavam menos impacto na camada de dados e vice-versa.
2.11.1. Modelo
O modelo é responsável pelos dados e pelas regras de negócio da
aplicação. Ele que interage com os repositórios de dados e executa as operações
da aplicação.
2.11.2. Visão
A visão é responsável por apresentar os dados para o usuário. Os mesmos
dados podem ser apresentados de diversas formas diferentes, como tabelas,
formulários ou gráficos, sem que seja necessário reescrever o código de acesso
aos dados para cada forma de apresentação.
2.11.3. Controlador
O controlador é responsável pela comunicação entre as camadas visão e
modelo. Ele trata entradas dos usuários, invoca as regras de negócio pertinentes
na camada modelo e apresenta os dados através da camada de visão.
2.12. Arquitetura JSP Modelo 2
A arquitetura do modelo 2 é aderente ao padrão MVC trabalhando com uma
abordagem para aplicações WEB que combina JSP e Servlets. Ele foca nos
pontos fortes de cada tecnologia, usando as JSP para a camada de visão e os
Servlets como controladores, tratando as entradas dos usuários e se comunicando
com a camada modelo. As JSP não contêm nenhuma regra de negócio, apenas
apresentando dados de objetos previamente criados pelos Servlets e pelos
objetos de negócio.
2.13. Framework
No paradigma de orientação a objeto, Frameworks são conjuntos de classes
que podem ser reutilizadas para construir aplicações dentro de um contexto
específico. Um framework oferece classes genéricas que devem ser entendidas
na construção de uma nova aplicação.
Vários frameworks aderentes aos padrões MVC e JSP Modelo 2 serão
estudados nos próximos capítulos.
3. METODOLOGIA E CRITÉRIOS
3.1. Metodologia
3.1.1.
Identificação de características das ferramentas
No início do estudo será feito um levantamento das características comuns
aos vários frameworks estudados. Além de ser um dos objetivos do trabalho, essa
etapa reduz o tempo de aprendizado, pois procura isolar características
específicas das comuns.
3.1.2.
Estudo das características específicas das ferramentas
Após o estudo das características comuns, é necessário estudar mais
detalhadamente cada framework, conhecer seus pontos fortes e fracos. Essa
etapa visa agilizar a realização da etapa seguinte.
3.1.3.
Desenvolvimento de uma aplicação
Será definida uma pequena aplicação que deve ter sua camada visão e
controladora desenvolvida usando cada um dos frameworks em estudo. A
aplicação terá os tipos básicos de relacionamentos entre entidades, alguns
cadastros com interação com o usuário e algum processamento de negócio.
A regra de negócio da aplicação será desenvolvida com usando a tecnologia
EJB e a API de persistência Java (JPA). Esta regra de negócio deve ser
aproveitada por todas as implementações feitas com os frameworks.
3.2. Critérios
3.2.1.
Velocidade do desenvolvimento
A produtividade no processo de desenvolvimento de software é cada vez
mais cobrada. A demanda tem crescido de forma muito rápida e os prazos tem
ficado menores. Uma das principais características esperadas dos frameworks em
estudo é a sua capacidade de eliminar trabalho repetitivo e acelerar o
desenvolvimento.
3.2.2.
Integração com EJB3
Será verificado se a solução é capaz de interagir com a camada de negócio
escrita com EJB3, se são necessárias configurações ou bibliotecas adicionais. A
camada desenvolvida com o Framework deve ser capaz de utilizar a
implementação prévia das regras de negócio.
3.2.3.
Controle de estados
O controle de estados é um dos desafios da programação WEB. É
necessário que a ferramenta permita um controle da maneira adaptável a diversos
cenários e de maneira simples, para facilitar o desenvolvimento.
3.2.4.
Facilidade de uso
Será analisada a facilidade de instalação e a integração com as principais
interfaces de desenvolvimento gratuitas, Eclipse e NetBeans. A possibilidade de
depuração e de testes automatizados no código desenvolvido.
3.2.5.
Curva de aprendizado e Documentação
Será avaliada a complexidade da solução, a quantidade de arquivos de
configuração necessários, a consistência da documentação, a quantidade de
exemplos disponíveis e a existência de tutorias para treinamento de pessoal.
3.2.6.
Utilização no mercado
A utilização no mercado é muito importante. Quanto mais difundida a
tecnologia, maior a possibilidade de se encontrar profissionais já experientes.
Além disso, soluções com muito uso costumam ser levadas em conta nas
especificações de novos padrões.
4. FRAMEWORKS AVALIADOS
4.1. WEBWORK
WEBWORK é um framework para desenvolvimento de aplicações WEB em
Java produzido pelo projeto Open Symphony. Ele visa aumentar a simplicidade do
código e a produtividade dos desenvolvedores. Provê padrões de interface com o
usuário, suporta internacionalização e uma robusta camada de validação, tanto na
camada cliente quando na camada do servidor.
4.2. Struts
O Struts é um framework open source desenvolvido pela fundação apache
para desenvolvimento de aplicações WEB com Java EE que encoraja a
programação no modelo MVC(Model-View-Controller). Ele provê um tratador de
requisições e de respostas, que auxilia o tratamento das interações entre cliente e
servidor. Também é disponibilizado um conjunto de bibliotecas de tags para
facilitar a construção de aplicações baseadas em forms HTML.
O Struts oferece duas versões de seu framework, a versão 1, que é
reconhecida como o framework mais popular para aplicações WEB em Java, e a
versão 2.0, que surgiu da união da equipe do projeto Struts com a equipe do
projeto WERBWORK. Anteriormente a versão 2 era conhecida como WEBWORK
2.
Este trabalho focará na versão 2 do framework, por trazer uma série de
recursos novos e pelo fato de que ela deve substituir gradativamente a versão 1.
4.3. Spring
O Spring é um framework open source para desenvolvimento de aplicações
Java em geral. Existem extensões mais específicas para desenvolvimento WEB.
O Spring não tem um modelo de programação específico. O framework traz uma
grande quantidade de recursos organizada em módulos. Entre os recursos estão
uma camada de abstração para JDBC, suporte a soluções ORM como Hibernate e
JPA, suporte a EJB3, recursos de integração com outros frameworks, recursos
para programação orientada a aspectos e, no núcleo do framework, um contêiner
de inversão de controle.
Para este trabalho será usada a versão 2.0 do framework.
4.4. Tapestry
O Tapestry é um framework para desenvolvimento de aplicações WEB, no
modelo MVC (Model-View-Controller) construído sobre a API Java Servlet. Dessa
forma suas aplicações podem ser executadas em qualquer contêiner de Servlets
ou servidor de aplicação. O desenvolvimento com Tapestry consiste em criar
páginas padrão em HTML combinadas com código java utilizando, opcionalmente,
arquivos descritores XML.
O framework tenta assumir a responsabilidade por funções recorrentes no
desenvolvimento de aplicações WEB, como manutenção de estado, validação de
entradas do usuário, internacionalização e tratamento de exceções.
4.5. JBoss Seam
JBoss Seam é um framework para construção de aplicações WEB em Java
que integra diversas tecnologias, como AJAX, JSF, EJB3, Java Portlets e BPM. O
desenvolvimento com o framemework é baseado em POJOs como anotações
Java.
JSF e EJB3 são tecnologias poderosas para o desenvolvimento de
aplicações WEB. Os EJB são excelentes para tratar os eventos do JSF e as Entity
Beans provem um modo transparente de mapeamento com a base de dados
relacional. Elementos visuais poderiam manter seu estado através de Entity
Beans.
O JEE ainda não traz uma padrão para integração de JSF e EJB3, fazendo
com que desenvolvedores tenha que desenvolver muito código para tal função. O
JBoss Seam foi projetado justamente para preencher a lacuna de integração entre
essas grandes tecnologias.
5. REFERENCIAS
FORD, N. Art of Java Web Development.Greemwich: Manning, 2003
DEITEL H. M., DEITEL P.J., Java How to Program. Sexta Edição, Prentice Hall.
2004
Hunter, J. Java Servlet Programming. Primeira Edição. Sebastopol: O’Reilly,
1998