Atenção: esse artigo tem dois vídeos complementares.
Clique e assista o primeiro!

Clique e assista o segundo!

De que se trata o artigo:

Uso conjunto das tecnologias Java Persistence API (JPA) 2.0 e JavaServer Faces (JSF) 2.0 integradas através de Enterprise JavaBeans (EJB) 3.1 para o desenvolvimento de uma rede social aos moldes do Orkut ou Facebook.


Para que serve:

JPA é a tecnologia padrão para gerenciamento de bancos de dados em Java, e permite trabalhar de maneira simples e orientada a objetos com banco de dados. JSF é a tecnologia padrão para geração de interfaces Web. Utilizando EJB para integrá-las, é possível criar aplicações web de maneira simples e poderosa.


Em que situação o tema é útil:

As tecnologias apresentadas são especificações oficiais que todo desenvolvedor Java EE deve conhecer. Por serem oficiais, o número de projetos que as utilizam é grande. Ademais, são ferramentas práticas e poderosas que barateiam o custo do desenvolvimento web em Java.

EJB, JPA e JSF: uma amizade possível:

Como Java Persistence API (JPA), JavaServer Faces (JSF) e Enterprise JavaBeans são tecnologias oficiais da plataforma Java EE, a maioria dos desenvolvedores já conhece ou já trabalhou com alguma destas ferramentas. Entretanto, aprender a integrá-las pode ser bastante complicado para o iniciante. Assim, veremos neste artigo, através do desenvolvimento de uma rede social, como usar estas ferramentas em conjunto para obter maior produtividade no desenvolvimento de aplicações web em Java.

A plataforma Java EE é uma das principais ferramentas para desenvolvimento de software para a Web. Além de sua robustez, Java EE é vantajosa por incluir tecnologias que podem ser muito úteis ao programador, facilitando a escrita, análise e manutenção de código. Este artigo apresenta três destas tecnologias: JPA 2, EJB 3.1 e JSF 2.0. Cada uma delas pode ser desafiadora de se compreender; juntas podem ser ainda mais complexas. Assim, este artigo apresentará o uso conjunto destas ferramentas de maneira prática, com pouca ênfase na teoria e muito foco nos diversos passos a serem executados.

Para estudarmos o passo-a-passo do desenvolvimento com estas tecnologias, desenvolveremos uma pequena aplicação: uma rede social, aos moldes de Orkut e Facebook. Durante todo o artigo, explicaremos como executar cada uma das tarefas necessárias para a criação do software. Porém, como tanto o software quanto o tema são amplos, a aplicação não será finalizada neste artigo. Aqui, prepararemos o ambiente e criaremos as primeiras funcionalidades.

Tecnologias estudadas

Cada uma das tecnologias apresentadas possui uma função específica em Java. Java Persistence API 2.0 (JPA 2), por exemplo, é responsável por gerenciar a interação com o banco de dados de maneira abstrata. Utilizando JPA, a persistência de dados é executada de maneira orientada a objetos. Deste modo, o desenvolvedor pode programar usando apenas conceitos de orientação a objetos, sem se preocupar com conceitos relacionais – como tabelas – ou detalhes do banco de dados.

JavaServer Faces 2.0 (JSF 2.0), por sua vez, permite a criação de páginas HTML ou qualquer outro tipo de conteúdo servido via HTTP. A especificação JSF 2.0 descreve um sofisticado framework para desenvolvimento Web, que possibilita gerar conteúdo a partir de classes responsáveis pela lógica da aplicação e telas criadas através da tecnologia Facelets.

Existem várias maneiras de se fazer classes JPA conversarem com as classes de JSF; utilizar Enterprise JavaBeans (EJB) é um modo popular. EJBs são classes que seguem determinadas convenções de modo que seu gerenciamento (criação, deleção, fornecimento, resolução de dependências, etc.) fica a cargo do servidor em que a aplicação estiver executando. EJBs já foram bastante complicados, mas, na versão 3.1, são bem simples de usar – inclusive para fazer a interação entre JPA, JSF e classes de negócio de uma aplicação. Grosso modo, a relação entre JPA 2.0, JSF 2.0 e EJB 3.1 pode ser representada como no diagrama da Figura 1.

Figura 1. Como EJB, JPA e JSF se relacionam.

Veremos como essa relação se dá na prática, desenvolvendo uma pequena aplicação: uma rede social (tal como Orkut e Facebook) bem simples, chamada Java Friends.

Montando um ambiente

Como EJB, JPA e JSF são especificações, precisamos escolher uma implementação. Neste artigo, utilizaremos o GlassFish v3, um servidor de aplicações desenvolvido pela Oracle (antigamente pela Sun) que implementa as três tecnologias. Também usaremos o Eclipse IDE for Java EE Developers sem plugins específicos – embora o Eclipse tenha bons plugins para se trabalhar com EJB e JSF (como o JBoss Tools), preferimos usar apenas as funcionalidades básicas da IDE para podermos estudar melhor o papel de cada componente da aplicação, visto que alguns seriam gerados automaticamente por outras ferramentas. Como um banco de dados será necessário, utilizaremos PostgreSQL nos exemplos, mas qualquer banco relacional seria satisfatório. Para concluir, assumimos que GlassFish, Eclipse e PostgreSQL já estão instalados em sua máquina.

Antes de escrevermos a aplicação, é preciso configurar o ambiente. Assim, veremos nas próximas seções como preparar o banco de dados, o servidor GlassFish e o Eclipse para nossa aplicação. Por vezes, esses passos anteriores ao desenvolvimento não são óbvios nem explicitados. Nesta matéria, tentaremos evitar este problema.

Criando a base de dados

Na nossa rede social, uma pessoa pode ter zero ou mais amigos. Além disso, mensagens podem ser enviadas entre pessoas, sendo que cada mensagem tem um remetente e um destinatário. O diagrama de classes da nossa aplicação pode ser visto na Figura 2.

Figura 2. Relacionamento entre entidades.

Assim, no banco de dados relacional haverá uma relação N:N entre pessoas e duas relações 1:N entre mensagens e pessoas. Para simplificar, a relação entre pessoas fará distinção entre quem convida e quem é convidado para ser amigo. O diagrama físico do banco de dados pode ser visto na Figura 3. O script DDL correspondente está na Listagem 1. Note, no script, como foram criadas algumas sequences; elas serão usadas para gerar as chaves primárias das entidades.

Figura 3. Diagrama entidade-relacionamento da base de dados da aplicação.

Para nossa aplicação, crie um banco de dados chamado javafriends no PostgreSQL. Depois, execute o script da Listagem 1 no banco.

Listagem 1.Script DDL para geração da base de dados de nossa aplicação.

  CREATE TABLE jf_pessoa (
    pessoa_id   integer primary key,
    nome        varchar (200),
    usuario     varchar (50),
    senha       varchar (200),
    idade       integer 
  );
  CREATE SEQUENCE jf_pessoa_sequence_id;
   
  CREATE TABLE jf_amizade (
    convidante integer references jf_pessoa(pessoa_id),
    convidado  integer references jf_pessoa(pessoa_id),
    primary key (convidante, convidado)
  );
   
  CREATE TABLE jf_mensagem (
    mensagem_id     integer primary key,
    remetente       integer references jf_pessoa(pessoa_id),
    destinatario    integer references jf_pessoa(pessoa_id),
    titulo          varchar(200),
    conteudo        text
  );
  CREATE SEQUENCE jf_mensagem_sequence_id; 

Integrando o GlassFish com o Eclipse

É possível controlar o GlassFish a partir do Eclipse, o que é prático e muito útil. Para isso, na aba Servers do painel inferior (Figura 4), clique com o botão direito sobre a área branca e escolha a opção New > Server no menu.

Figura 4. Aba Servers.

Na caixa de diálogo da Figura 5, escolha a opção GlassFish > GlassFish v3 Java EE 6 (ou outra versão que você esteja utilizando). Caso a opção não esteja disponível, clique no link Download additional server adapters; se estiver conectado com a Internet, você poderá baixar um adaptador.

Figura 5. Caixa de diálogo para configurar novo servidor no Eclipse.

Uma vez selecionado o servidor, clique em Next. Se aparecer a tela da Figura 6, nenhum servidor GlassFish foi configurado anteriormente, sendo necessário selecionar um ambiente de execução Java e indicar o diretório de instalação do servidor GlassFish. Se o Eclipse já estiver configurado, haverá ao menos um ambiente para selecionar.

Figura 6. Configuração do ambiente de execução.

Clicando em Next, vamos para a tela em que configuramos a conexão do Eclipse com o servidor (Figura 7). A maior parte dos dados virá preenchida. Geralmente, só é necessário fornecer a senha do console de administração. A senha padrão é adminadmin.

Figura 7. Configurando domínio e autenticação em console de administração.

Na próxima tela, é possível adicionar projetos já existentes ao servidor, mas não faremos isto. Clique apenas em Finish.

Para saber se o servidor está bem configurado, basta executá-lo através dos botões de interação da Figura 8. O primeiro botão executa (levanta) o servidor em modo de depuração (debugging). O segundo inicia o servidor em modo de execução normal, que é mais rápido. Já o terceiro botão levanta o servidor em modo de profiling, e o quarto encerra o servidor. Assim, para ativar o servidor basta selecioná-lo na listagem e clicar no segundo botão.

Figura 8. Botões de interação com servidores.

Se tudo der certo, o servidor estará executando e ao acessar a URL http://localhost:8080 a página apresentada será como a exibida na Figura 9.

Figura 9. Página inicial do GlassFish.

Criando um recurso JDBC no GlassFish

Como a aplicação precisa acessar um banco de dados, configuraremos uma conexão no GlassFish.

Primeiro, é preciso disponibilizar o driver JDBC do banco de dados utilizado para o servidor de aplicações. No caso, como o artigo é baseado em PostgreSQL, baixe o driver JDBC4 encontrado em http://jdbc.postgresql.org/ e salve-o no diretório lib do GlassFish. Agora basta iniciar (ou reiniciar) o servidor que ele estará pronto para se conectar ao SGBD. O procedimento para outros bancos de dados é o mesmo.

Figura 10. Console de administração do GlassFish.

Após adicionar o driver ao servidor e iniciá-lo, acesse o console de administração do GlassFish em http://localhost:4848. Autentique-se e aparecerá a tela da Figura 10.

O usuário padrão do console de administração do GlassFish é “admin”, e a senha padrão é “adminadmin”. Use a senha padrão se você não a alterou em algum momento.

Na árvore do lado esquerdo, entre em Resources > JDBC > Connection Pools. No painel à direita, aparecerá a tela da Figura 11, na qual são listados os pools de conexões já configurados. Para adicionar nosso novo pool, clique em New....

Figura 11. Tela de gerenciamento de pools de conexões providos pelo GlassFish.

Na tela que aparece (Figura 12), temos de dar um nome ao novo pool, assim como selecionar o tipo de recurso e o fornecedor do banco de dados. No nosso exemplo, chamamos o pool de JavaFriendsPool, definimos que o recurso seria do tipo javax.sql.DataSource e o fornecedor como PostgreSQL. Enfim, clicamos em Next.

Outros tipos de recursos são javax.sql.XADataSource, um recurso que permite gerenciar transações que alterem dois ou mais bancos de dados; javax.sql.ConnectionPoolDataSource, que permite fazer pooling (reaproveitamento) de conexões; e java.sql.Driver, um driver JDBC comum.

Figura 12. Adicionando um novo pool de conexões.

Na tela seguinte, vários parâmetros da configuração podem ser alterados, mas só é necessário adicionar mais algumas propriedades. O nome do servidor (localhost) já é fornecido, como pode ser visto na Figura 13; precisamos então adicionar as propriedades DatabaseName (nosso banco de dados se chama javafriends), User (usuário que se autenticará no banco) e Password (senha do usuário). Marque também opção Ping, localizada mais acima. Se ela estiver habilitada, a conexão com o servidor será testada sempre que for alterada, o que facilita encontrar erros de configuração.

Figura 13. Painel de adição/edição de propriedades do recurso.

Uma vez criado o pool de conexões, é preciso publicá-lo como um recurso JDBC, para que possa ser encontrado através de JNDI (Java Naming and Directory Interface, uma API para localização de recursos que é utilizada por padrão em servidores de aplicação Java). Para fazer isso, no console de administração, clicamos em Resources > JDBC > JDBC Resources. Vemos a tela da Figura 14.

Figura 14. Tela de gerenciamento de recursos JDBC.

Como vamos adicionar um novo recurso, clicamos em New.... Na tela que pode ser vista na Figura 15, definimos o nome JNDI para o recurso e selecionamos o pool correspondente. Chamaremos nosso recurso de JavaFriendsJDBCResource e, naturalmente, utilizaremos o pool JavaFriendsPool. Se achar necessário, é possível adicionar também uma descrição ao recurso.

Figura 15. Painel de adição de propriedades do recurso.

Entrados os dados, clicamos em Ok. Nosso servidor de aplicação já possui um recurso fornecendo conexão com o banco de dados, agora basta nossa aplicação solicitá-lo.

Seria possível configurar a conexão com o banco de dados no arquivo persistence.xml da própria aplicação. Entretanto, é mais prático e portável configurar a conexão no servidor de aplicações: se mudarem o banco de dados ou parâmetros precisarem ser alterados, basta mudar a configuração do recurso, sem precisar alterar o arquivo dentro da aplicação. Se a aplicação for implantada em outro servidor de aplicação, basta configurar no servidor utilizado um recurso com o mesmo nome.

Estrutura de um Web Archive (WAR)

Uma aplicação que use EJB 3.1, JPA 2 e JSF 2.0 deve ser distribuída como um Web Archive – ou simplesmente WAR. Um WAR é um arquivo compactado (do tipo Zip) com classes Java compiladas, arquivos JAR, JSPs (ou, no caso de JSF 2.0, Facelets), arquivos de configuração e outros recursos, como imagens, arquivos de tradução etc.

WARs são como um tipo específico de JAR para empacotamento de aplicações web em Java. Para instalar – ou melhor, implantar – um WAR, basta copiá-lo para a pasta de implantação do servidor de aplicação (no caso do GlassFish, é <diretório de instalação>/domains/domain1/autodeploy).

Até EJB 3.0, aplicações web que utilizassem EJBs precisavam ser empacotadas em um Enterprise Archive (EAR) que, por sua vez, deveria conter dois arquivos, um JAR com os EJBs e um WAR com os componentes da aplicação Web. Isto ainda é possível na especificação EJB 3.1 – e recomendável, caso seus EJBs devam fornecer serviços para outras aplicações – mas não é mais necessário, o que facilita o desenvolvimento de aplicações web. Por isso empacotaremos nossa aplicação apenas em um WAR.

Um WAR deve conter, na sua raiz, os componentes da aplicação Web: JSPs, facelets, imagens etc. Além disto, deve conter um diretório chamado WEB-INF. Dentro deste diretório estarão os arquivos de configuração da aplicação, como o arquivo web.xml e, no caso em que se use JSF, o arquivo faces-config.xml. As classes utilizadas pela aplicação também devem vir dentro do diretório WEB-INF, mais precisamente em um subdiretório chamado classes. Quaisquer recursos que as classes devam poder acessar também devem estar dentro deste diretório. É o caso do arquivo persistence.xml, que configura a conexão de JPA com a base de dados e vem dentro de um diretório chamado WEB-INF/classes/META-INF. Ademais, na raiz do WAR virá outro diretório, também chamado META-INF, que contém o arquivo MANIFEST.MF com dados sobre o empacotamento. Um exemplo da estrutura pode ser visto na Figura 16.

Figura 16. Estrutura de um WAR.

Criando o projeto no Eclipse

O projeto no Eclipse poderia ter qualquer estrutura, mas usaremos uma estrutura que facilite a geração do WAR. Deste modo, começamos criando um novo projeto, que vamos chamar de JavaFriends. Na tela da Figura 17, apenas entramos com o nome e apertamos Next.

Figura 17. Criação de novo projeto.

Na próxima tela, primeiro, removemos o diretório src do build path. Para isso, basta selecionar o diretório e clicar no link Remove source folder 'src' from build path. Também vamos adicionar um diretório, chamado WEB-INF/src, clicando no link Create new source folder. Nesta tela, ainda mudaremos o campo Default output folder para JavaFriends/WEB-INF/classes ...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo