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,elovise@granbery.edu.br,

melisepaula@gmail.com,

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 object-

relationary 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.

2

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

hibernate.cfg.xml

HibernateConfiguration

SessionBD

ClasseHibernateDAOClasseDAO

DAOFactory HibernateDAOFactory

Instancia

Instancia

Implementa

Implementa

Abre

Conecta

AplicativoClasse

Interface

XML

Driver

Banco de Dados

Figura 1 – Modelo da arquitetura DAO a ser utilizada neste tutorial

3

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

4

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 objeto-

relacional 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.

5

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 5 – Preenchimento do ClassPath com o arquivo hivernate3.jar

Figura 4 – Construção de novas Librarys no NetBeans

6

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

7

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

8

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:

9

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).

10

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.

11

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:

12

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

13

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:

14

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

15

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:

16

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 DE CONFIGURAÇÃO (HIBERNATECONFIGURACAO)

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:

17

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:

18

Figura 30 – Configuração do arquivo log4j.properties

CONSTRUINDO A APLICAÇÃO PRINCIPAL

Crie uma classe executável (Java Main Class) e chame-a de

AplicacaoTexto.java

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

19

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

20

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.