tutorial: desenvolvimento de aplicações com o hibernate no netbeans

TUTORIAL: DESENVOLVIMENTO DE APLICAÇÕES
COM O HIBERNATE NO NETBEANS
Glauber da Rocha Balthazar, Fábio Mendes Ramos Guimarães, Melise Maria
Veiga de Paula, Elio Lovisi Filho
Bacharelado em Sistemas de Informação – Faculdade Metodista Granbery (FMG)
Rua Batista de Oliveira, 1145 - 36010-532 - Juiz de Fora – MG
{gbalthazar,fguimaraes}@si.granbery.edu.br,[email protected],
[email protected],
Abstract. In this article presents the tutorial one that it an approach, of
practical form is presented, the use of the Framework of Hibernate persistence
in NetBeans. For this, the construction of a guided application is considered
the Objects, in Java, that has access a Data base Relationary Object through
an architecture developed for this type of application. After that, it is
presented all the steps for the necessary configuration of the objectrelationary mapping between the application and the bank.
Resumo. Neste artigo é apresentado um tutorial que aborda, de forma
prática, a utilização do Framework de persistência Hibernate no NetBeans.
Para isso, é proposto a construção de uma aplicação Orientada a Objetos, em
Java, que acesse um Banco de Dados Objeto Relacional por meio de uma
arquitetura desenvolvida para este tipo de aplicação. Em seguida, são
apresentados todos os passos para a configuração necessária do mapeamento
objeto-relacional entre a aplicação e o banco.
INTRODUÇÃO
Para PRESSMAN (2005), o software tornou-se uma das forças motoras das
empresas, é ele quem dirige a tomada de decisão nos negócios. Este fato justifica a
crescente importância que o processo de desenvolvimento de software vem adquirindo
nos ambientes organizacionais. Contudo, atualmente, observa-se que apesar da evolução
das ferramentas de apoio ao desenvolvimento de software, esta atividade ainda é
considerada uma tarefa bastante complexa para os profissionais da área.
Neste contexto, pode-se observa duas vertentes. De um lado, os usuários vêm se
tornado cada vez mais exigentes, fato que aumenta a complexidade dos requisitos e a
expectativa em relação aos resultados esperados. Além disso, as empresas têm
percebido que um sistema de informação pode ser o seu diferencial perante suas
concorrentes, pois a gerencia das informações e a garantia da segurança e
disponibilidade destas de forma rápida, confiável e sigilosa em qualquer ponto a
qualquer momento permite que diretores, gerentes e vendedores tomem decisões de
forma mais precisa e rápida [OLIVEIRA].
Por outro lado, diversas tecnologias vêm surgindo e amadurecendo, fornecendo
ao desenvolvedor uma variedade de linguagens, ferramentas e softwares que o
aproximem desta realidade. Um exemplo disto é a Orientação a Objetos que vem sendo
explorada no intuito de encontrar padrões para desenvolvimento de softwares de forma
mais simples com uma alta manutenibilidade e reusabilidade dos códigos escritos.
Considerando o cenário descrito, este artigo pretende apresentar, de forma
prática uma visão de como desenvolver uma aplicação orientada a objetos com acesso a
um banco de dados objeto-relacional. Para tanto, serão empregados a linguagem de
programação JAVA e o ambiente de desenvolvimento NetBeans como IDE (Interface
Desktop Environment). Além disso, o Hibernate será usado como a camada de
persistência que deverá fazer a interface entre a aplicação e o sistema gerenciador de
banco de dados PostegreSQL.
O artigo está organizado da seguinte maneira, na seção 2, é descrita a
Arquitetura DAO (Data Access Object) que será utilizada para a construção das classes
de mapeamento e gerencia das informações para o Hibernate. Na seção 3, é descrita a
aplicação a ser considerada nos exemplos práticos. Os capítulo seguintes exploraram a
prática no NetBeans na construção de aplicações.
A ARQUITETURA DAO
Para a construção da aplicação, vamos adaptar o padrão proposto por
[FAERMAN] na revista Java Magazine de Janeiro de 2005, que descreve uma política
para a construção de aplicações que utilizam um Framework para persistência dos
dados.
Será empregada a arquitetura DAO (Data Access Object), onde um objeto
intermediário é responsável pelo acesso aos dados do sistema, independente do SGBD
empregado.
Na figura 1, apresenta-se a arquitetura DAO utilizada para a construção da
aplicação, definindo-se o relacionamento entre as classes que irão compor a estrutura de
persistência do Hibernate.
Action
(Aplicação)
FactoryClasses
Instancia
Implementa
DAOFactory
hibernate.cfg.xml
Implementa
HibernateDAOFactory
Instancia
ClasseHibernateDAO
ClasseDAO
HibernateConfiguration
Abre
Aplicativo
Classe
Interface
XML
Driver
Conecta
BD
Session
Banco de Dados
Figura 1 – Modelo da arquitetura DAO a ser utilizada neste tutorial
2
O banco de dados a ser utilizado assim como o nome de usuário e a senha para
acesso e demais propriedades do banco são mapeados para um arquivo XML
denominado hibernate.cfg.xml, a partir de uma Factory de Classes.
O HibernateDAOFactory será a classe responsável por gerar instâncias dos
objetos a serem utilizados na aplicação. Estes objetos são descritos na arquitetura de
forma genérica como ClasseHibernateDAO (na aplicação será visto como
FuncionárioHibernateDAO) e estes implementarão as suas respectivas interfaces,
também descritas de forma genérica como ClasseDAO (na aplicação como
FuncionarioDAO) que contém todas as assinaturas dos métodos de gerência dos objetos
como incluir (persistir), excluir, dentre outros.
A partir deste ponto, é aberta uma seção com o banco através do
HibernateConfiguration e os métodos chamados poderão ser executados.
A APLICAÇÃO
Com o objetivo de manter um aspecto técnico e prático deste trabalho, será
considerada uma aplicação contendo apenas uma classe, Funcionário. A partir desta
classe, serão construídas as principais funcionalidades de gerência de objetos como
persistir, recuperar apenas um objeto, recuperar todos os objetos persistidos e exclusão.
Desta forma, todos os atributos para esta classe são apresentados na figura 2.
Funcionario
private String nome;
private int idade;
private String cpf;
Figura 2 – Classe Funcionário
Para a arquitetura utilizada como modelo de desenvolvimento desta aplicação, os
métodos de persistência e recuperação dos objetos ficarão escritos em uma classe
específica, deixando apenas na classe Funcionario os atributos e seus métodos de acesso
além do construtor default, apresentando desta forma uma classe com todas as
3
características POJO (Plain Old Java Object) para manipulação do Framework de
persistência Hibernate.
O banco de dados utilizado será o PostgreSQL por ser um banco objetorelacional e apresentar as características de estabilidade e confiabilidade. Desta forma,
os objetos gerados pela aplicação serão persistidos e recuperados no banco através do
Hibernate.
CONSTRUINDO E GERENCIANDO UM PROJETO NO NETBEANS
Para se construir um novo projeto no NetBeans vá até o menu File e escolha New
Project. Em seguida, Na janela New Project vá até a lista Categories, escolha General e
na lista Projects escolha Java Application e em seguida clique em Next.
Na tela seguinte New Java Application, digite o nome do projeto e defina o
diretório do projeto, na caixa Project Name. Neste exemplo digite
MiniCursoHibernatePratica.
Após,
direcione
o
Project
Location
para
C:\minicursoHibernate e desmarque a caixa de opção referente ao Create Main Class
como mostrado na figura 3.
Figura 3 – Definição do nome e diretório do projeto
Por último clique em Finish.
GERENCIANDO LIBRARY’S NO NETBEANS 5.0
Para a utilização das bibliotecas do Hibernate e do driver JDBC que fará o acesso ao
banco, será necessária a construção de Librarys no NetBeans para o armazenamento e
organização destes arquivos. Para isso, deve-se criar duas Librarys, uma para o
Hibernate e outra para o driver JDBC do PostgreSQL.
O NetBeans permite a construção destas Librarys através da opção Library
Manager no menu Tools. Ao escolher esta opção a janela Library Manager será aberta e
basta clicar no botão New Library... no canto inferior esquerdo da mesma como na
figura 4.
4
Figura 4 – Construção de novas librarys
Agora, informe o nome para a Library na caixa Library Name. Para este
exemplo, digite Hibernate e clique em ok.
Com a Library já construída, adicione agora as bibliotecas (.Jar) do Hibernate
3.1. Para isso, clique no botão Add Jar/Folder... Direcione para o local em que o
Hibernate foi descompactado e localize o diretório hibernate-3.1. Dentro dele localize o
arquivo “hibernate3.jar” e adicione-o clicando nele e em seguida no botão Open. Veja
na figura 5 que o ClassPath foi preenchido.
Figura 4 – Construção de novas Librarys no NetBeans
Figura 5 – Preenchimento do ClassPath com o arquivo hivernate3.jar
5
Mas ainda faltam as demais Librarys existentes no diretório lib do hibernate.
Para tanto, volte no botão add Jar/Folder... e direcione para o sub diretório lib existente
no diretório hibernate-3.1 e adicione todas as librarys existentes (todos os arquivos jar) e
em seguida clicando no botão Open, veja na figura 6:
Figura 6 – Seleção das demais bibliotecas do Hibernate na pasta Lib
Figura 6 – Seleção das demais bibliotecas do Hibernate na pasta Lib
Neste momento todas as librarys do hibernate foram adicionadas a Library
criada anteriormente. Por fim, clique em Ok para terminar a construção desta nova
Library no NetBeans.
Repita agora o mesmo procedimento para a construção de uma Library para o
driver JDBC do PostgreSQL. Dê o nome para ela de JDBCPostgreSQL como na figura
7.
Figura 7 – Definição do nome da Library
Após isso, adicione o arquivo postgresql-8.2dev-501.jdbc2.jar .
Por último falta apenas adicionar as duas Librarys criadas anteriormente ao
projeto. Para isso, vá ao inspetor de Projetos e clique com o botão direito sobre as
Libraries e escolha Add Library como na figura 8.
Figura 8 – Adicionando uma Library ao projeto
Escolha agora as duas Librarys criadas anteriormente e clique no botão Add
Libary. Aguarde um momento enquanto o NetBeans atualiza o ClassPath e veja que
6
todas as bibliotecas do Hibernate e do Driver do PostgreSQL foram adicionadas ao seu
projeto através da figura 9.
Figura 9 – Visualizando as bibliotecas adicionadas ao projeto
CONSTRUINDO A CLASSE FUNCIONÁRIO
A classe Funcionário é a uma classe de negócio da aplicação e será mapeada no
Hibernate como tabelas no banco de dados. Classes deste tipo deve estar dentro de um
padrão definido como POJO, que é uma classe que contém todos os atributos
encapsulados e definidos os seus métodos de acesso get e set além do método construtor
default.
Para isso, clique com o botão direito em cima do Default Package e escolha New
e logo em seguida File/Folder, como ilustrado na figura 10.
Figura 10 – Construindo uma nova classe
7
A janela New File será aberta, nela visualize a lista das Categories e escolha
Java Classes e na lista de Files Types escolha Java Class, veja a figura 11.
Figura 11 – Escolhendo o tipo de arquivo
Em seguida, veja a figura 12, clique em Next. Na tela seguinte digite o nome
para a classe (Funcionario) e clique em Finish.
Figura 12 – Definindo o nome da Classe
Pronto, a classe Funcionario foi criada. Agora, complete esta classe com os
atributos descritos na figura 13:
8
Figura 13 – Atributos da classe Funcionario
Construa agora os métodos getters e setters para cada um deles. Para isso, clique
primeiramente em cima de qualquer um dos atributos e vá até o menu Refactor e
escolha Encapsulate Fields...
Na tela Encapsulate Fields – Funcionario, marque todos os métodos a serem
construídos e desmarque a caixa Preview all changes, veja na figura 14:
Figura 14 – Seleção dos métodos a serem construídos
Em seguida clique em Next e pronto, todos os métodos de get e de set foram criados.
CONSTRUINDO O MAPEAMENTO DO FUNCIONÁRIO
Para utilização da camada de persistência, é necessário indicar qual(is) tabela(s)
do banco de dados corresponde à classe de negócio. Isso é feito por meio de um
mapeamento que indica essa correspondência. Neste artigo, visando facilitar o
entendimento do leitor, o mapeamento será feito por meio de um arquivo XML. Outra
forma de mapeamento pode ser vista em BAUER, KING (2005).
9
Para realizar o mapeamento proposto, crie um arquivo XML, selecionando com
o botão direito o Default Package e escolhendo a opção New e em seguida File/Folder,
veja na figura 15:
Figura 15 – Construção do arquivo XML
Na janela seguinte, New File apresentado na figura 16, nas Categories escolha
XML e na lista Files Type escolha XML Document:
Figura 16 – Escolhendo um arquivo XML
Em seguida, clique em Next.
Na última tela, como nome para este arquivo, digite Funcionario.hbm. Por
último clique em Next e na próxima tela em Finish. Veja a figura 17.
10
Figura 17 – Término da construção do arquivo XML
Agora, preencha este arquivo como mostrado na figura 18:
Figura 18 – Configuração do arquivo de mapeamento
No mapeamento acima, a classe Funcionario da aplicação é relacionada à tabela
funcionario do banco de dados. As tags property indicam o mapeamento dos atributos
da classe com os campos da tabela, descrevendo também os valores que podem ser
atribuídos aos mesmos.
CONSTRUINDO O ARQUIVO HIBERNATE.CFG.XML
Seguindo as instruções dispostas na seção 5 deste artigo, construa um novo
arquivo XML e dê o nome para ele de: hibernate.cfg.xml
Em seguida, digite o código da figura 19:
11
Figura 19 – Configuração do arquivo hibernate.cfg.xml
No código acima são definidos, entre outros, o driver de conexão, o usuário e a
senha de acesso, bem como os arquivos que descrevem o mapeamento das classes de
negócio.
CONSTRUINDO A FÁBRICA DE CLASSES – FACTORYCLASS
Para evitar a dependência entre o aplicativo principal e a implementação
concreta do DAO, iremos empregar o padrão Factory Method, no qual um objeto é
responsável pela criação de outros, “fabricando-os”. [FAERMAN, 2005]
Sendo assim, nosso próximo passo consiste em construir a classe FactoryClass
para gerência do Banco de Dados a ser utilizado. Para isso, crie uma nova classe e dê o
nome para ela de FactoryClasses. Em seguida, digite o código mostrado na figura 20
para esta classe:
Figura 20 – Configuração do arquivo.FactoryClasses.java
12
Obs.: Neste ponto, algumas linhas do seu código irão ficar marcadas de vermelho. Não
se preocupe, elas indicam apenas que as demais classes ainda não foram construídas,
isso será feito nos próximos passos.
Agora, crie a interface para a construção do FuncionarioDAO. Chame esta
interface de DAOFactory e digite o código da figura 21 para ela:
Figura 21 – Configuração da interface DAOFactory
Após ter construído a interface DAOFactory, vamos implementá-la em uma
classe. Para isso, crie uma nova classe e a chame de HibernateDAOFactory.
Nesta classe, vista na figura 22, implemente a interface DAOFactory e em
seguida, sobrescreva o método criarFuncionarioDAO( ) adicionando a ele a
funcionalidade de instância do FuncionarioHibernateDAO( ).
Figura 22 – Configuração da classe HibernateDAOFactory
CONSTRUINDO OS DAO’S
Vamos, primeiramente, construir a interface do Funcionario. Nela nós teremos
as assinaturas dos métodos de gerenciamento um novo funcionário. As implementações
serão realizadas posteriormente.
Para isso, crie uma nova interface e chame-a de FuncionarioDAO e adicione a
ela as seguintes assinaturas de métodos descritas na figura 23:
13
Figura 23 – Assinaturas dos métodos do FuncionarioDAO
O método carregarUm irá retornar um funcionário que possua o nome
especificado no parâmetro. Já o método carregarTudoOrdenadoNome irá recuperar
todos os funcionários existentes no banco de dados, ordenados pelo atributo nome. Os
métodos gravar e excluir realizam as funções de inserção e exclusão para os objetos
que forem definidos como seus parâmetros.
Como segundo passo, iremos construir a classe FuncionarioHibernateDAO. Para
isso, construa uma nova classe e dê este nome para ela. Veja o código na figura 24:
Figura 24 – Implementação dos métodos de gerenciamento da classe Funcionario
14
Agora, vamos escrever os códigos de cada um destes métodos, veja nas figuras
abaixo:
a) Método carregaUm, visto na figura 25:
Figura 25 – Implementação do método carregaUm
As classes Session e Transaction controlam, respectivamente, a abertura e o
fechamento de sessões de acesso ao banco de dados, e o início e a conclusão de
transações. Emprega-se a classe Criteria para definir-se critérios de busca de objetos.
Esses critérios podem ser definidos utilizando a classe Expression. [BAUER & KING,
2005]
No código anterior, é definido um critério de busca de objetos da classe
Funcionario, retornando somente aquele que possuir o atributo nome igual ao parâmetro
informado ao método.
b) Método carregaTudoOrdenadoPorNome, visto na figura 26:
Figura 26 – Implementação do método carregaTudoOrdenadoPorNome
No método acima retorna-se uma lista de objetos da classe Funcionario,
ordenados pelo atributo nome.
c) Método gravar, visto na figura 27:
Figura 27 – Implementação do método gravar
Já neste método, deve-se informar um objeto da classe Funcionario o qual será
persistido no banco de dados empregando-se o método saveOrUpdate.
d) Método excluir, visto na figura 28:
15
Figura 28 – Implementação do método excluir
Finalmente, no método acima, um objeto da classe Funcionario é excluído do
banco de dados por meio do método delete.
CONSTRUINDO
O
HIBERNATE
(HIBERNATECONFIGURACAO)
DE
CONFIGURAÇÃO
Como último passo deverá ser construído o arquivo que permitirá abrir uma
sessão com o banco. Este arquivo é uma classe que chama-se HibernateConfiguração,
com os métodos openSession e criaSessionFactory. O primeiro é responsável por
verificar se já existe uma sessionFactory instanciada na aplicação. Se sim, ele retorna
esta sessão para a aplicação que requisitar. O segundo método faz o inverso, caso a
session esteja instanciada, ele será responsável por permitir a instância de uma nova
session, baseando-se no arquivo hibernate.cfg.xml, definido anteriormente.
Para isso construa uma nova classe e chame-a de HibernateConfiguração e
complete-a de acordo com a figura 29, veja:
16
Figura 29 – Configuração do arquivo HibernateConfiguracao.java
CONSTRUINDO UM ARQUIVO DE LOG
Para acompanhar a execução do sistema, e facilitar a identificação de possíveis
erros, será empregado o framework log4j. Para isso, deve-se criar um arquivo com as
suas configurações.
Para construir este arquivo, proceda da seguinte forma:
Vá até o menu File e escolha New File
Na janela New File, escolha nas categorias Other e na lista de Files Types
Properties File. Logo em seguida, clique em Next.
Em seguida, digite para o nome do arquivo: log4j e clique em Finish.
Agora, copie para dentro deste arquivo o código descrito na figura 30:
17
Figura 30 – Configuração do arquivo log4j.properties
CONSTRUINDO A APLICAÇÃO PRINCIPAL
Crie uma classe
AplicacaoTexto.java
executável
(Java
Main
Class)
e
chame-a
de
Em seguida, adicione o código da figura 31 à esta classe:
Figura 31 – Código fonte da aplicação
Agora, para persistir um novo Funcionário, digite o código da figura 32, veja:
Figura 32 – Código para persistir um novo funcionário
18
Para listar todos os funcionários, digite o código da figura 33:
Figura 33 – Código para listar todos os funcionários
Para carregar apenas os dados de um funcionário digite o código da figura 34:
Figura 34 – Código para listar apenas um funcionário
E para excluir um funcionário, digite o código da figura 35:
Figura 35 – Código para excluir um funcionário
19
CONCLUSÃO
pO presente artigo procurou demonstrar de forma prática, a implementação de
uma aplicação simples em Java utilizando a camada de persistência Hibernate para o
armazenamento e manipulação de objetos em um SGBD OR.
Para isso, o artigo foi escrito sobre a forma de um tutorial, apresentando todos os
passos necessários para a construção deste tipo de aplicação começando desde a escrita
das classes POJO, passando pelo mapeamento objeto-relacional e a construção dos
métodos de persistência que utilizam o Hibernate para a manipulação das informações.
Além disso, seguiu-se uma arquitetura (padrão) de desenvolvimento, através de
um modelo proposto por Julio Ferman, na revista Java Magazine, e adaptado para a
solução deste artigo, procurando seguir uma forma de desenvolvimento que se aplique,
de forma genérica, a todas as classes de qualquer sistema que venha a ser desenvolvido
em Java e que faça uso do Hibernate.
Com isso, o artigo mostra como organizar as classes de negócio existentes nas
aplicações com o objetivo de prepará-las para a persistência em um banco de dados, a
forma de construir uma aplicação seguindo uma arquitetura de desenvolvimento própria
para persistência de objetos em bancos relacionais sem gerar códigos desnecessários,
confusos e mal organizados e como aplicar os métodos de gerencia (persistir, recuperar,
dentre outros) em uma aplicação explorando ao máximo a produtividade da mesma sem
que isso gere custos exagerados de processamentos para a máquina, tornando a
aplicação leve e rápida, mesmo se tratando de mapeamento de informações entre um
banco relacional e uma aplicação orientada a objetos.
BIBLIOGRAFIA
BAUER, C. e KING, G. Hibernate em ação. Primeira Edição. 2005: Rio de Janeiro,
Editora Ciência Moderna.
EMILO, C. e SEVER, P. NetBeans IDE 4.1 – Para desenvolvedores que utilizam a
tecnologia Java. Primeira Edição. 2005: Rio de Janeiro, Editora Brasport.
OLIVEIRA, Djalma P. R. de. Sistemas de Informações gerenciais: estratégias,
táticas operacionais. Sétima Edição. São Paulo: Atlas, 2001.
PRESSMAN, R. Engenharia de Software. Sexta Edição. McGraw-Hill, 2005.
SILBERSCHATZ, Abraham, KORTH, Henry F. e SUDARSHA, S. Sistema de Banco
de Dados. Terceira Edição. São Paulo: Makron Books, 1999.
FAERMAN, Julio. Design Patterns Aplicados. Java Magazine, Rio de Janeiro, edição
20, p. 52-58, jan. 2005.
20