Descrição
Nessa atividade
você irá aprender a desenvolver aplicações utilizando Enterprise JavaBeans. Será
desenvolvido um sistema Web para compra e venda de produtos.
Exemplo
de Aplicação
Inicialmente
iremos criar uma aplicação de exemplo para entender o funcionamento e a
forma de desenvolvimento de aplicações com Enterprise JavaBeans. Siga
atentamente o procedimento abaixo, pois posteriormente será necessário
aplicar o mesmo procedimento para execução do trabalho.
A aplicação de
exemplo consistirá em um sistema de consulta ao cadastro de clientes de
uma empresa. Iremos utilizar nesta atividade o NetBeans, o servidor
de aplicação Glassfish v3 e o
servidor de banco de dados Java DB.
Criando
o Banco de Dados de Exemplo
O primeiro
passo consiste em criar o banco de dados que será usado pela aplicação de
exemplo. Em uma situação real, talvez esse banco já esteja disponível, e
bastaria apenas utilizá-lo na aplicação.
Inicie o Java
DB, que está disponível na janela Serviços do NetBeans, no item Banco de
Dados, como mostra a figura:
Após a
inicialização do JavaDB, abra
novamente o menu do Java DB e
clique em Criar banco de dados. Dê ao banco de dados o nome
'Clientes' e forneça o nome do usuário e a senha (o valor padrão é ‘app’).
Note que será
criada uma conexão no item Banco de Dados da janela de
Serviços do NetBeans. Para
conectar-se à base de dados você deve clicar com o botão da direita sobre
a conexão (jdbc:derby://localhost:1527/Clientes) e selecionar
a opção Conectar.
Crie agora uma
tabela de exemplo. Abra a conexão e, na pasta APP àTabelas, selecione o
menu Criar Tabela.
Crie uma tabela
chamada Clientes, com a seguinte estrutura:
A tabela
aparecerá dentro da pasta Tabelas da conexão, na janela de
Serviços.
Em seguida,
crie alguns dados para teste. Clique sobre a tabela com o botão da direita
e selecione Visualizar Dados.
Por fim,
pressione Alt+I para abrir a
janela de inserção de dados e registre os dados de alguns clientes na
tabela.
Criando
o Projeto de Exemplo
O projeto de
exemplo consistirá em um sistema Web para busca por clientes cadastrados
na base de dados da empresa.
Crie um Projeto
(Arquivo à Novo
Projeto) do tipo
Aplicativo Corporativo, da categoria Java EE.
Clique em
Próximo, defina o nome do projeto (no exemplo será usado o nome
CadastroClientes) e determine o local
onde ele será armazenado.
Clique
novamente em Próximo, escolha o servidor
de aplicação que será usado – o GlassFish
v3, mantenha as demais opções inalteradas e clique o botão
Finalizar.
Note que foram
criados dois módulos junto com o projeto – o módulo EJB e o módulo Web. O módulo EJB corresponderá à camada de
negócio da aplicação, na qual serão implantadas as regras de negócio e
onde ficará também o modelo mapeado a partir do banco de dados. Já o módulo Web se preocupará somente com o interfaceamento com o usuário, através de páginas
Web.
Criando
os Beans de Entidade
Começaremos a
implementação do módulo EJB pela definição das
entidades que compõem a aplicação e que serão mapeadas a partir da base de
dados criada anteriormente.
Primeiramente é
necessário criar uma unidade de persistência para que sua aplicação possa
interagir com a base de dados. Selecione o menu
Arquivo à Novo
Arquivo, escolha o
projeto CadastroClientes-ejb e selecione o
tipo de arquivo Unidade de Persistência da Categoria
Persistence.
Na janela
aberta será possível informar o nome da unidade de persistência, do
provedor de persistência TopLink, e criar uma nova fonte de dados
(jdbc/Clientes, que apontará para
a conexão criada anteriormente); mantenha selecionadas as opções de
utilização das APIs de transação e da estratégia
de criação automática das tabelas do banco de dados. Para concluir a
criação da unidade de persistência basta clicar no botão Finalizar.
Em seguida
iremos gerar um bean de entidade
automaticamente, a partir da tabela criada na base de
dados.
Selecione o
menu Arquivo à Novo
Arquivo
e escolha
o tipo de arquivo Classes de Entidade do Banco de Dados
da
Categoria Persistence.
Clique em
Próximo, escolha a conexão com a base de
dados que será utilizada (jdbc/Clientes), selecione a
tabela CLIENTES e clique em Adicionar. Clique o botão Próximo
e dê um nome ao pacote no qual serão criados os componentes (por
exemplo, ejb). Por fim, clique em
Finalizar.
Examine o
código do bean de entidade criado a
partir da tabela na pasta ‘Pacotes de códigos-fonte’ do
projeto.
Criando o Bean de Sessão
Agora temos que
criar um bean de sessão, que
servirá de "fachada" para acesso às entidades. Nele serão implementados os métodos de negócio, que efetuarão as
consultas na base de dados de clientes da empresa. Para criá-lo, selecione
o menu Arquivo à Novo
Arquivo
e escolha
a categoria Java EE e o tipo de
arquivo Bean de sessão.
Defina o nome
do bean de sessão (ClienteFachada) e
coloque-o no mesmo pacote que os beans de
entidade (ejb). Esse bean não deve manter o estado da sessão (stateless) e deve possuir apenas interfaces
locais. Depois de selecionar estas opções, clique o botão
Finalizar.
O bean será criado e
seu código será mostrado na janela de edição.
Para que o
bean
de sessão tenha acesso às entidades da aplicação, ele deve possuir uma
referência para o gerenciador de entidades. Clique no código do bean de sessão com o botão da direita do mouse
e selecione a opção Inserir código
à Utilizar
Gerenciador de Entidade (Persistence
à Utilizar
Gerenciador de Entidade na versão 6.X do NetBeans). O atributo de utilização do gerenciador de
entidade (EntityManager em) será criado
automaticamente. Note que esse atributo possui a anotação @PersistenceContext, que
indica que o contêiner deve injetar a dependência.
A
funcionalidade do bean deve ser implementada em métodos de negócio. A assinatura do método deve ser adicionada à
interface local do bean: import java.util.List; @Local public interface ClienteFachadaLocal { List<ejb.Clientes> getListaClientes(); }
Adicione o
código destacado em negrito ao arquivo com o código do bean de sessão: import java.util.List; import javax.persistence.Query; ... @Stateless public class ClienteFachada implements ClienteFachadaLocal { ... public List<ejb.Clientes> getListaClientes() { Query query = em.createNamedQuery("Clientes.findAll"); return query.getResultList(); } }
Note
que o método criado executa a consulta Clientes.findAll,
criada automaticamente no bean de
entidade: @NamedQuery(name = "Clientes.findAll", query = "SELECT c FROM Clientes c")
Criando
o Módulo Web
O módulo
Web servirá como
interface com o usuário da aplicação. Este módulo conterá um facelet que permitirá que o usuário visualize
os dados dos clientes cadastrados no banco de dados.
Primeiramente
deve ser adicionado um bean gerenciado
JSF (Arquivo à Novo
à Bean gerenciado JSF) ao módulo Web (CadastroClientes-war) da aplicação
corporativa. Dê um nome ao bean (por
exemplo, ClientesMBean) e defina seu escopo como
sendo de sessão. O código do bean gerenciado será aberto
no editor.
Clique com o
botão da direita no editor de código fonte e selecione Inserir código
à
Chamar
Enterprise Bean. Na janela
mostrada abaixo, selecione o bean
de sessão
(ClienteFachadaBean)
e clique o botão OK.
Um atributo que
representa o bean de sessão (clienteFachadaBean)
será adicionado ao código do bean
JSF:
@EJB
private ClienteFachadaLocal clienteFachada;
Note que sobre o atributo existe
uma anotação @EJB, que indica que essa dependência será injetada pelo
contêiner.
Adicione o
método abaixo ao código do bean
gerenciado JSF: public List<Clientes> getListaClientes() { return clienteFachada.getListaClientes(); }
Agora remova a
página index.jsp existente
na pasta 'Páginas Web' do módulo Web (CadastroClientes-war) e crie uma página JSF,
clicando no menu Arquivo à Novo
Arquivo e selecionando Página JSF. Dê o nome index.xhtml ao facelet. Em seguida, clique o botão
Finalizar para criar a página, que será mostrada no editor.
Substitua todo
o código do facelet pelo código abaixo, que exibe
uma tabela com os clientes cadastrados no banco de dados: <?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core"> <h:head> <title>Lista de Clientes</title> </h:head> <h:body> <f:view> <h:form> <h1><h:outputText value="Lista de Clientes"/></h1> <h:dataTable value="#{clientesMBean.listaClientes}" var="item"> <h:column> <f:facet name="header"> <h:outputText value="Id"/> </f:facet> <h:outputText value="#{item.id}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText value="Nome"/> </f:facet> <h:outputText value="#{item.nome}"/> </h:column> </h:dataTable> </h:form> </f:view> </h:body> </html>
Testando
a Aplicação
Para compilar,
empacotar e implantar a aplicação no servidor de aplicação basta clicar o
botão  . Aguarde que
todo o processo seja executado (isso pode demorar alguns minutos). Uma
página será mostrada no navegador Web com a lista de clientes.
Aprimorando o
Exemplo
Você pode criar
novos métodos de negócio no bean de
sessão e no bean gerenciado JSF e novas
páginas JSF que acessem esses métodos.
Por exemplo,
para cadastrar um cliente você deve instanciar um novo bean de entidade e chamar o método em.persist(),
passando o novo bean como parâmetro para
que o mesmo seja adicionado à tabela. Para remover uma instância, execute
o método em.remove(), passando o
bean de entidade a ser removido como
parâmetro.
Você também
pode criar novas consultas adicionando uma named query
ao bean de entidade, seguindo
o formato:
...
@NamedQuery(name = "Clientes.findByDDD",
query = "SELECT c FROM
Clientes c WHERE c.telefone LIKE
:DDD"),
...
Para executar a
consulta, crie uma query, defina os valores de
parâmetros e a execute em um método de negócio no bean de sessão, conforme
mostrado abaixo:
public List<ejb.Clientes> getClientesByDDD(int DDD)
{
Query
query = em.createNamedQuery("Clientes.findByDDD");
query.setParameter("DDD", "(" + DDD +
")%");
return query.getResultList();
}
Para efetuar
consultas mais complexas você deve executar o método em.createNativeQuery(), passando como parâmetro o
código da consulta SQL a ser executada no banco de dados. Esse método
retorna um objeto do tipo Query, cujo
resultado pode ser obtido chamando o método getResultList(), que retorna uma lista
com o resultado da consulta, ou getSingleResult(), que retorna um Object como resultado. Operações do tipo Update e Delete
também podem ser executadas como uma Native Query, chamando o método executeUpdate().
Tarefa:
Site de Compra e Venda de Produtos
O projeto final da disciplina
consiste em implementar um Web site no qual usuários poderão comprar e vender produtos, semelhante ao Mercado Livre e ao eBay. O site pode permitir a venda de qualquer tipo de produto, ou ser direcionado a
uma área específica (imóveis, veículos, livros, etc).
Um usuário deve
se cadastrar no site, fornecendo suas informações pessoais e um email e
senha. Um usuário pode cadastrar produtos que serão ofertados no site. Um
produto deve ser associado a uma categoria e possuir um preço e uma
descrição. O sistema deve permitir a busca de produtos por nome ou categoria. As informações sobre o produto serão mostradas em uma página de
detalhes do produto. O usuário que se interessar pelo produto pode adquiri-lo e efetuar o pagamento online.
O vendedor receberá uma notificação em sua área privada e o status do produto será alterado para vendido.
Inicialmente
devem ser criadas as tabelas no banco de dados. Crie tabelas para
armazenar os dados dos usuários e dos produtos à venda. Em seguida crie os beans
de entidade a partir das tabelas do banco de dados. Na etapa seguinte, crie um bean de sessão com os métodos de negócio que permitirão
cadastrar usuários, pesquisar, comprar e vender produtos no site. Por
fim, crie a camada web da aplicação, que deve conter facelets que permitam a
execução de cada funcionalidade prevista, e um bean JSF que utilizará os
métodos de negócio disponibilizados pelo bean de sessão EJB.
Avaliação
A atividade
deve ser desenvolvida em duplas. A apresentação deve ser feita até o dia
06/06. Os dois integrantes da equipe devem estar presentes no
momento da apresentação. Será verificado o funcionamento do programa e em
seguida os alunos devem responder oralmente a questões formuladas pelo
professor sobre o código fonte do programa. Podem ser atribuídas notas
diferentes aos integrantes de uma equipe, dependendo das respostas às
perguntas sobre o código do programa efetuadas pelo professor. Caso um dos
integrantes não esteja presente ou demonstre não conhecer o código do
programa, este ficará com nota zero na atividade. Em caso de cópia do
código de outra equipe, ambas terão nota igual a
zero.
Dúvidas
Atendimento aos
Alunos
- Horário:
Terças-feiras das 16:20 às 18:00
- Local:
Prédio do INE - Sala 305.
E-Mail
f r a n k @ i
n f . u f s c . b
r
l a u . l u n g @ i n f . u f s c . b r
Mantida por Frank Siqueira. Atualizada em
24/05/2011.
|