Descrição
Nessa atividade
você irá aprender a desenvolver aplicações utilizando Enterprise JavaBeans. Será
desenvolvido um sistema Web para troca de mensagens entre usuários,
semelhante ao existente em redes sociais, para ser utilizado na Intranet
de uma empresa.
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 da atividade prática.
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 Persistence
à Utilizar
Gerenciador de Entidade. 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:
Troca de Mensagens
A tarefa
consiste em desenvolver um sistema Web que permita a troca de mensagens
entre os funcionários de uma empresa. O sistema
deve ser implementado usando EJB, JSF e JPA. As entidades devem
ser mantidas no banco de dados.
Suponha que já
há no banco de dados uma tabela com os funcionários da empresa. O
funcionário entrará com seu login e senha no navegador
Web e visualizará as mensagens recebidas. As mensagens poderão ser
respondidas ou removidas. O sistema também permitirá o envio de novas
mensagens a outros funcionários.
Inicialmente
devem ser criadas as tabelas no banco de dados. Crie tabelas para
armazenar os dados dos funcionários e as mensagens (contendo remetente,
destinatário, data e hora de envio, assunto e corpo). 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. 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
15/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
05/06/2011.
|