Descrição
Nessa
atividade você irá aprender a desenvolver aplicações utilizando Enterprise
JavaBeans. Será criado um site de venda de ingressos pela Web utilizando EJB,
JSF e a API de persistência do Java.
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 ointerfaceamento 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 à NovoArquivo,
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 Beande 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 Entidadena
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 umaNative Query, chamando o método executeUpdate().
Tarefa: Site
de Venda de Ingressos Online
Através do
site será possível adquirir ingressos para eventos, como shows, festas, competições
esportivas, etc. A lista de eventos com ingressos à venda será exibida na
página inicial. Ao selecionar um evento, serão exibidos os detalhes sobre o
evento e o preço dos ingressos (suponha que o preço é fixo, independentemente
de gênero, idade, profissão, lote, etc.). Na página do evento, deve ser
possível solicitar a compra de um ou mais ingressos. Para efetivar a compra,
o cliente será direcionado a uma página de pagamento, na qual informará a
forma de pagamento e o cartão de crédito ou débito do qual o valor dos
ingressos será cobrado. Suponha que o ingresso será sempre retirado no local do
evento, mediante apresentação do cartão utilizado para pagamento.
As
entidades manipuladas pela aplicação devem ser mantidas no banco de dados. Crie
uma tabela contendo uma lista de eventos e outra tabela para registrar as
vendas de ingressos efetuadas. Em seguida, gere os beans de entidade correspondentes
a partir das tabelas do banco de dados.
Na etapa
seguinte, crie um enterprise bean de sessão com os métodos de
negócio necessários para implementação da aplicação Web. Os métodos do bean
de sessão manipularão as entidades, que serão mapeadas para o banco de dados
com o auxílio da JPA.
Por fim,
crie a camada web da aplicação utilizando facelets JSF. Crie também um
bean gerenciado JSF, cujos métodos serão invocados a partir dos formulários
contidos nos facelets, e que irão invocar os métodos de negócio
contidos no enterprise bean de sessão.
Avaliação
A
atividade deve ser desenvolvida em duplas. A apresentação deve ser feita até
o dia 28/11. 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
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 17/11/2012.
|