MÓDULO 3 - Fazendo Com Que o Mundo Orientado a Objetos se
Comunique com o Mundo Relacional - Banco de Dados
Download e Instalação do Banco de Dados
Utilizaremos o banco de dados PostgreSQL como repositório de dados de nosso projeto. O primeiro passo é realizar o download deste banco de dados na seguinte url:
http://www.postgresql.org/download/
Figura 39 - Realizando o download do Banco de Dados Postgres
Salientei na imagem anterior a questão de ser a versão do Postgres para Windows, pois é neste sistema operacional que este projeto está sendo criado. Caso você esteja utilizando outro sistema operacional, terá que clicar no link correspondente a sua versão.
Clique sobre o link para a versão em Windows. Você será remetido para página de instaladores.
Figura 40 - Link de download do Windows Installer do PostgreSQL
Clique sobre o link de Download para que possamos escolher qual versão do Postgres iremos realizar o download para posterior instalação.
Figura 41 - Selecionado a versão do instalador do PostgreSQL conforme o sistema operacional
Como estou utilizando um sistema operacional de 64 bits, realizei o download referente a versão Win x86-64, conforme está salientado em vermelho na figura anterior. Caso você possua um sistema operacional de 32 bits, deverá baixar o instalador referente a versão Win x86-32.
Faça o procedimento de instalação no formato Next to Next, mantendo as configurações conforme sugeridas pelo instalador mas, quando chegar na tela referente a senha do super usuário postgres, defina a seguinte senha para ele: postgres.
Tanto senha, como nome de usuário serão os mesmos mas, você poderá definir outra senha a seu gosto, mas você terá que mudá-la posteriormente em seus códigos java caso faça isso, pois os exemplos vistos de conexão a banco de dados serão com o usuário e senha descritos anteriormente.
Figura 42 - Definindo o password para o usuário Postgres
Clique no botão Next para continuar. Na próxima tela, você terá que definir a porta de acesso. Mantenha o valor indicado (porta 5432) pelo instalador. e clique sobre o botão Next para continuar.
Figura 43 - Definindo a porta de acesso ao banco de dados PostgreSQL
A partir da próxima tela, continue no método Next to Next até que o processo de instalação inicie.
Quando o processo de instalação estiver concluido, você será remetido a seguinte tela:
Figura 44 - Finalizando a instalação do Banco de Dados
Desmarque a opção referente ao Stack Builder e clique sobre o botão Finish.
Neste ponto, concluímos a instalação do banco de dados Postgres em nosso computador. O próximo passo é acessar este banco de dados através de um utilitário vindo no pacote do instalador e criar uma base de dados (database) que será utilizada em nosso projeto.
Criando a base de dados
Para gerenciar as bases de dados do Postgre, foi instalado em nosso computador o utilitário PgAdmin 3. Acesse este utilitário para ter acesso as bases de dados. Observe:
Figura 45 - Executando o utilitário PgAdmin III
Observe que foi instalado a versão 9.4 do Postgre, no servidor localhost (máquina local), na porta 5432. Também note o servidor está com um X vermelho. Isso ocorre pois não estamos logados no banco de dados ainda. Para isso, clique sobre o nome do servidor para que a tela de logon apareça.
Insira a senha postgres, conforme definimos anteriormente e clique sobre o botão OK, para efetuar o processo de logon. Caso tudo esteja correto, o X vermelho sumirá a estrutura de árvores de objetos abaixo do servidor será exposta. Observe:
Figura 46 - Treeview exibindo os databases existentes
O próximo passo é criar o database para ser utilizado em nosso projeto. Para isso, clique com botão contrário do mouse sobre Databases e selecione a opção New Database.
Figura 47 - Criando o database da aplicação
Você será remetido para a caixa de diálogo New Database. Defina o nome do database como livrariawebdb e clique sobre o botão OK para concluir. Não faremos configuração alguma a mais neste database.
Figura 48 - Definindo o nome e criando o database da aplicação
Para finalizar, após a criação do deste database devemos criar uma sequence, que será utilizada por gerar as chaves primárias de cada registro cadastrado na tabela de livros. Para isso, na janela do utilitário pgAdmin III, na barra de ferramentas, clique sobre o botão Execute arbitrary SQL queries, para que a seguinte caixa de diálogo seja exposta.
Figura 49 - Criando a sequence hibernate_sequence_livros
Digite no editor a seqüência de comandos conforme está descrito na figura acima e clique sobre o botão Execute query. Após, na guia Messages, observe se a mensagem Query returned successfully foi exibida, mostrando que tudo foi feito de forma correta.
Na treeview Server Groups do utilitário pgAdmin III, você poderá visualizar a sequence criada.
Note também, que em Tables, não existe nenhuma tabela criada. Isso será feito posteriormente. Com relação a instalação de banco de dados e criação de database e sequence o que vimos até aqui é o suficiente. O próximo passo é configurarmos nosso projeto para utilizar JPA, através do framework Hibernate e com isso, poderemos realizar mapeamento objeto-relacional entre tabelas e classes. Veremos isso a seguir.
Adicionando as Dependências do Hibernate e do PostgresSQL
Para adicionar as dependências do Hibernate, devemos ir até a url
http://hibernate.org/orm/downloads/, no item Maven Repository e copiar os itens selecionados em vermelho na figura a seguir:
Figura 51 - Maven e a lista de dependencias para a utilização do hibernate
Após copiar tais itens, os mesmos devem ser colados no arquivo pom.xml que, lembrando, é o arquivo utilizado pelo Maven para gerenciar as dependências do projeto.
Para finalizar a adição de dependências ao projeto, vamos agora adicionar as que são referentes ao banco de dados de Postgres. Para isso, vá até a seguinte url:
Figura 52 - Maven e a lista de dependencias para a utilização do Postgres
Do mesmo jeito que você fez para as dependências do hibernate, copie o que está em amarelo na figura acima e cole-o na área de dependências do arquivo pom.xml. Automaticamente todas as dependências serão baixadas.
Seu arquivo pom.xml e a relação de dependências deverão ficar como na figura a seguir:
Criando o arquivo hibernate.cfg.xml
Este arquivo é responsável por conter determinadas configurações que são utilizadas para configurar o Hibernate em uma aplicação.
A partir deste ponto devemos começar a organizar nosso projeto em packages, que nada mais são que pastas. Para isso, criaremos um package (folder), com o nome de util, dentro do folder livrariaweb.
Clique com o botão contrário do mouse sobre livrariaweb. No menu de contexto, selecione as opções New, Package. A seguinte caixa de diálogo será exposta:
Figura 54 - Criando o package livrariaweb.util
Em name, o folder livraweb já virá preenchido. Basta que você digite .util e por fim clique sobre o botão Finish para que o novo folder seja criado.
A partir da criação deste folder (util), criaremos o arquivo de configurações para o hibernate citado anteriormente. Então, clique sobre o package livrariaweb.util com o botão contrário do mouse e selecione as opções: New, Other.
Figura 55 - Criando um arquivo do topo XML File
Na próxima caixa de diálogo digite hibernate.cfg.xml para o nome do arquivo e após sobre o botão Finish.
O arquivo será criado automaticamente dentro do package livrariaweb.util. Abra o arquivo, adicione o seguinte conteúdo a ele e após salve-o.
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "- //Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property> <property name="hibernate.connection.driver_class">org.postgresql.Driver</property> <property name="hibernate.connection.url">
jdbc:postgresql://127.0.0.1:5432/livrariawebdb?autoReconnect=true </property>
<property name="hibernate.connection.username">postgres</property> <property name="hibernate.connection.password">postgres</property> <property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property> <property name="connection.pool_size">5</property> <!-- Mapeamento da Classes Beans -->
<mapping class="livrariaweb.bean.Livro" /> </session-factory>
</hibernate-configuration>
Note que o conteúdo deste arquivo configura o Hibernate para utilizar o banco de dados Postgres com base em tudo o que fizemos anteriormente.
O próximo passo é criarmos uma classe utilitária, que será utilizada pelo Hibernate, para que ele possa ler as configurações necessárias para se "conectar" com a base de dados.
Essa classe utilitária também será no package livrariaweb.util. Então, selecione o package citado e clique sobre ele com o botão contrário do mouse. Após, selecione as opções New, Class.
Na caixa de diálogo New Java Class, no item name digite HibernateUtil.java, que será o nome da classe. Para finalizar, clique sobre o botão Finish para que a classe seja criada automaticamente.
Abra a classe HibernateUtil.java e adicione a ela o seguinte conteúdo: package livrariaweb.util;
import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.SessionFactory;
@SuppressWarnings("deprecation") public class HibernateUtil {
private static final SessionFactory sessionFactory; static {
try {
sessionFactory = new AnnotationConfiguration().
configure("livrariaweb/util/hibernate.cfg.xml") .buildSessionFactory();
} catch (Throwable ex) {
throw new ExceptionInInitializerError(ex); }
}
public static SessionFactory getSessionFactory() { return sessionFactory;
} }
Note que nesta classe estamos criando uma sessionFactory, ou seja, ela conterá todas as informações necessárias para posteriormente criarmos uma conexão com a base de dados.
Como estas configurações não estão presentes de forma direta nesta factory, as mesmas foram descritas no arquivo hibernate.cfg.xml, que é lido automaticamente quando esta linha é executada:
sessionFactory = new AnnotationConfiguration().
configure("livrariaweb/util/hibernate.cfg.xml")
Se tudo foi feito de forma correta até, sua estrutura de folder e files no Project Explorer, para este package, deve estar desta forma:
Figura 57 - Package livrariaweb.util e seus arquivos
Criando a Classe Livros Para Persitência de Dados
Utilizaremos neste ebook apenas uma classe, que será responsável por representar no mundo orientado a objetos (no Java) a tabela de livros que realmente conterá os dados referentes ao nosso crud de livros.
Não farei grandes relacionamentos ou algo do tipo. O negócio é ter uma classe que represente uma entidade (tabela) de um banco de dados e, a partir disso, possamos realizar operações básicas de crud, como inclusão, exclusão e alteração de registros.
Mas antes de criar a classe Livro, vamos criar outro package com o nome de bean, dentro do folder livrariaweb. Faça isso da mesma forma feita anteriormente para o package livrariaweb.util.
Depois de criado o package, iremos criar dentro dele a classe Livro. Para isso, clique com o botão contrário do mouse sobre livrariaweb.bean e após clique sobre as opções New, Class. Em name, coloque o nome da classe de Livro e após clique sobre o botão Finish.
A classe será automaticamente aberta do Eclipse e pode ser visualizada na estrutura de arquivos do Project Explorer.
O próximo passo é inserirmos os atributos na classe, que nada mais são que a representação dos campos que serão gerados na tabela Livro no banco de dados Postgres.
Esses atributos e a própria classe virão acompanhados de anotações, que nada mais são que informações que identificam e permitem manter a relação entre a classe no java e tabela no banco de dados.
O arquivo da classe Livro já deve estar aberto em seu Eclipse. O mesmo deverá ficar como mostra a figura a seguir:
Figura 59 - Classe Livro e seus atributos
A anotação @Entity indica que esta classe representa uma tabela do banco de dados. Neste caso em especifico, ela representará a tabela Livros.
A outra anotação, @SequenceGenerator indica a sequence que criamos anteriormente e será utilizada para gerar as chaves primárias, para cada registro, inserido na tabela Livros no banco de dados.
As anotações @Id e @GeneratedValue indicam que o atributo idLivro, que representa a coluna id_livro no banco de dados, servirá para representar a chave primária de cada registro
/objeto.
Para gerar os gets e sets destes atributos, basta clicar com o botão contrário do mouse na área branca da classe Livro e no menu de contexto, selecionar as opções Source, Generatte Getters and Setters.
Na caixa de diálogo que aparecerá, basta selecionar todos os itens que são demonstrados na figura a seguir:
Figura 60 - Gerando os getters e setters da classe Livro
Após, clique sobre o botão OK. Todos os getters e setters serão gerados automaticamente. Para finalizar, vamos geras os métodos hashCode e Equals. Para isso, clique com o botão contrário do mouse e no menu no de contexto, selecione as opções Source, Generate HashCode() and Equals().
Figura 61 - Gerando hashCode() and equals() classe Livro
Mantenha todas os atributos marcados e clique sobre o botão OK. Os métodos serão gerados automaticamente.
Para finalizar, vamos criar uma classe que será responsável por “testar” o que fizemos até aqui. Antes, devo lembrar, que quando criamos a sequence, também demonstrei que a tabela de Livros não existia no banco de dados. Então, a classe que criaremos agora, executará um método java, que “lerá” as informações presentes no arquivo hibernate.cfg.xml e fará, através de nossa classe, que a tabela Livros seja criada automaticamente, pois em nosso projeto, possuímos a Classe Livro, que está anotada como uma entidade.
Vamos lá. Clique com o botão contrário do mouse sobre Java Resources. Através das opções New, Class, crie uma classe com o nome de GeraTabela.
package livrariaweb;
import livrariaweb.bean.Livro;
import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.tool.hbm2ddl.SchemaExport; public class GeraTabela {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
AnnotationConfiguration conf = new AnnotationConfiguration() .configure("util/hibernate.cfg.xml");
conf.addAnnotatedClass(Livro.class);
SchemaExport sE = new SchemaExport(conf);
sE.create(true, true);
System.out.println(" A Tabela " + Livro.class.getName() + " foi criada.");
} }
Salve as alterações e agora vamos executar a classe. Para isso, vá até o menu Run, após Run as e por último clique sobre Java Application. Se tudo estiver correto, o processo de execução começara automaticamente e as informações de execução serão exibidas na guia Console, observe:
Figura 62 - Tela de console do Eclipse
Depois que o processo de execução for completado, poderemos ver a tabela criada no banco de dados, observe:
Figura 63 - Exibindo a criação da tabela de Livros no utilitário PgAdmin III
Tanto a tabela, quanto os campos, seguem os nomes definidos em @Table(name=””) e @Colum(name=””).
Uma classe Java deste tipo, também é conhecida entre os desenvolvedores como sendo um bean (POJOS), ou seja, uma classe que possui algumas características próprias, como um construtor vazio, atributos que possuem getters e setters associados a eles, são serializáveis e assim por diante.
Neste ponto, já estamos unido ambos os mundos relacional e orientado a objetos. O próximo é passo é criamos uma interface e uma classe utilitária que serão responsáveis por permitir que os métodos de CRUD de nosso projeto sejam executados. Isso será visto a seguir.
Criando o DAO da aplicação
DAO (Data Access Object), nada mais é que um padrão (design pattern) que tem a função de abstrair operações relativas a banco de dados. É claro, que este pattern é representado no Java por um objeto, que implementa uma interface e, através dela, é que faremos acesso a estes métodos de CRUD.
Vamos criar outro package a partir de livrariaweb com o nome de dao. Faça todo o procedimento para criação de packages visto nos passos anteriores.
Agora, selecione o package livrariaweb.dao com o botão contrário do mouse e no menu de contexto selecione as opções New, Other. Na caixa de dialogo do wizard, selecione a opção interface e clique sobre o botão Next.
Figura 64 - Criando uma Interface
Na próxima tela, em Name digite LivroDao para o nome da interface e clique sobre o botão Finish. O arquivo será criado e aberto automaticamente.
package livrariaweb.dao; import java.util.List;
import livrariaweb.bean.Livro; public interface LivroDao {
public boolean insereLivro(Livro livro); public boolean alteraLivro(Livro livro); public boolean excluiLivro(Livro livro); public Livro consultarLivro(Livro livro); public List<Livro> listarLivros();
}
Onde:
• insereLivro: insere um livro na tabela;
• alteraLivro: altera dados de um livro pré-cadastrado; • excluiLivro: exclui um livro cadastrado;
• consultarLivro: busca dados de apenas um livro em especfico; • listarLivros: traz todos os livros cadastrados.
Agora iremos criar a classe que realizará a implementação destes métodos, visto que a interface apenas garante o processo de assinatura e encapsulamento.
Agora, selecione o package livrariaweb.dao com o botão contrário do mouse e no menu de contexto selecione as opções New, Class. Em Name digite LivroDaoImpl para o nome da classe e clique sobre o botão Finish.
Adicione o seguinte conteúdo a classe: package livrariaweb.dao; import java.util.List; import livrariaweb.bean.Livro; import livrariaweb.util.HibernateUtil; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction;
public class LivroDaoImpl implements LivroDao { private Session session = null;
private Transaction transaction = null; public boolean insereLivro(Livro livro) {
boolean retorno = false; try {
session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction();
session.persist(livro); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; }
public boolean alteraLivro(Livro livro) { boolean retorno = false;
try { session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction(); session.update(livro); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; }
public boolean excluiLivro(Livro livro) { boolean retorno = false;
try { session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction(); session.delete(session.get(Livro.class, livro.getIdLivro())); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; }
Livro l = null; try {
session = HibernateUtil.getSessionFactory().openSession(); l = (Livro) session.get(Livro.class, livro.getIdLivro());
} catch (HibernateException e) { e.printStackTrace(); } finally { session.close(); } return l; }
public List<Livro> listarLivros() { List<Livro> list = null; try {
session = HibernateUtil.getSessionFactory().openSession(); list = session.createQuery("select l from Livro l").list(); } catch (HibernateException e) { e.printStackTrace(); } finally { session.close(); } return list; } } Onde:
• session = HibernateUtil.getSessionFactory().openSession(): a partir da classe HibernateUtil e do objeto sessionFactory uma sessão com o banco de dados é aberta. Tal sessão é atribuída a variável session.
• session.persist: insere um registro no banco de dados. • session.update: atualiza um registro no banco de dados. • session.delete: exclui um registro no banco de dados. • session.get: obtem um registro no banco de dados.
• session.createQuery: permite definir uma SQL para ser executada no banco dados. Neste caso, traz uma lista de livros.
• transaction = session.beginTransaction(): abre um processo de transação no banco de dados.
• transaction.commit(): comita, persiste as informações enviadas para o banco de dados.
• transaction.rollback(): desfaz tudo caso ocorra algum problema durante o processamento de alguma transação.
Seu package livrariaweb.dao e os arquivos criados anteriormente devem estar na seguinte forma no Project Explorer:
Figura 65 - Package livrariaweb.dao e seus arquivos
Sintetizando, temos nesta classe a implementação de todos os métodos necessários para realizar operações de CRUD no projeto que será criado posteriormente. Maiores conhecidos sobre Hibernate podem ser vistos no site http://hibernate.org/.
Aqui finalizamos este módulo. Instalamos o banco de dados, criamos o database e a sequence, adicionamos as dependências necessárias para trabalhar com Hibernate e Postgres, configuramos o Hibernate, criamos um JavaBean (POJO), testamos as configurações do Hibernate através de uma classe java que utiliza o Bean criado e por fim criamos a interface e classe de implementação para métodos de CRUD.