Material SII - parte 1

Prévia do material em texto

1 
 
Capítulo 1 – Persistência de Dados 
 
 Este capítulo apresenta o desenvolvimento de um exemplo de sistema para 
manutenção de dados de departamentos. Apresentam-se aqui as técnicas e as ferramentas 
empregadas neste desenvolvimento. 
 Esse sistema será desenvolvido empregando-se o paradigma da Orientação a Objetos, 
o Java, a IDE NetBeans, o framework Hibernate e o SGBD PostgreSQL. Apresenta-se aqui o 
desenvolvimento de um exemplo de caso de uso, que implementa as operações básicas de 
acesso a um banco de dados. 
A aplicação desenvolvida empregará a linguagem de programação JAVA, que é uma 
linguagem de programação orientada a objetos. No entanto a maioria dos SGBD's utilizados 
atualmente emprega o modelo relacional. Logo, existe a necessidade de realizar a “tradução” 
entre os dois modelos, empregando-se para tanto o framework Hibernate. 
 Nos próximos itens serão apresentadas as atividades necessárias para a criação de um 
aplicativo Java que acesse um banco de dados PostgreSQL empregando o framework 
Hibernate, utilizando os padrões MVC e DAO 
1.1. Padrões Empregados 
Um dos principais objetivos do padrão MVC - Modelo, Visão e Controle (Model, View 
and Controller) é a organização do código de uma aplicação em camadas, realizando assim a 
separação física dos componentes do software. Desta forma, a organização em camadas é a 
chave para a independência entre os componentes, objetivando desta forma agrupar 
componentes por responsabilidades em comum. 
A fundamentação da divisão das funcionalidades de um sistema em camadas surgiu 
como alternativa para solucionar alguns problemas existentes nas aplicações monolíticas, nas 
quais, dados e código eram armazenados em uma mesma máquina, na qual todas as 
funcionalidades eram definidas em um único módulo contendo uma grande quantidade de 
linhas de código e de difícil manutenção. 
Este modelo consiste em uma tríade de classes frequentemente usadas em sistemas 
interativos para construção de interfaces com o usuário. A implementação deste modelo 
mantém o núcleo funcional do sistema independente da interface. Assim, as interfaces 
internas podem permanecer estáveis, mesmo quando a interface necessita ser alterada para se 
adaptar a novas plataformas e dispositivos de interação. 
Com isso a apresentação, a lógica (negócio) e o acesso ao banco de dados estão 
2 
 
separados em camadas específicas, tornando os sistemas mais manuteníveis e garantindo a 
independência entre estas camadas. Desta forma, as camadas de negócio podem ser divididas 
em classes podendo ser agrupadas em pacotes ou componentes reduzindo as dependências 
entre as mesmas. Esta divisão facilita a reutilização por diferentes partes do aplicativo e até 
por aplicativos diferentes. 
 A abordagem MVC define como os componentes da aplicação irão interagir entre si. 
Este padrão de arquitetura divide os objetos em três conjuntos: 
 Modelo (Model), composto por objeto de entidade da aplicação; 
 Visão (View), composta por objetos de apresentação na tela; e 
 Controlador (Controller), que possui objetos que definem a maneira como a 
interface do usuário reage às entradas do mesmo. 
 
 
Além disso, para a manipulação dos dados do sistema foram empregados objetos de 
acesso, conhecidos como DAO (Data Access Object), que permitem que as regras de negócio 
sejam separadas das regras para acesso aos dados, de forma que sejam criadas classes 
exclusivas para o acesso ao SGBD. 
 
1.2. Preparando o Ambiente 
 Conforme citado anteriormente, para o desenvolvimento deste aplicativo será 
empregado o SGBD PostgreSQL. Para este tutorial foi criado um banco de dados chamado 
exemplo, em um SGBD com o usuário postgres e a senha também postgres. Utilize o 
aplicativo desejado para criar o banco. 
3 
 
 Nesse banco crie a tabela departamento utilizando o script abaixo: 
CREATE TABLE departamento( 
id SERIAL PRIMARY KEY, 
nome VARCHAR(60) , 
area VARCHAR(60) 
); 
Na ferramenta NetBeans crie um novo projeto Java chamado ExemploHibernate, sem 
classe principal, conforme figura abaixo. 
 
 
Agora inclua no seu pacote de código fonte (Source Package), os seguintes pacotes: 
dao, model, control e view. 
4 
 
 
 
 Além disso, será necessária a utilização das bibliotecas do Hibernate e do driver que 
fará o acesso ao banco de dados (PostgreSQL JDBC Driver). Para isso, vá ao inspetor de 
Projetos e clique com o botão direito sobre o item bibliotecas (Libraries) e escolha Adicionar 
Bibliotecas (Add Library), conforme as figuras a seguir. 
5 
 
 
 
 Agora, no pacote padrão (default package) crie um arquivo de configuração (New – 
Other). 
6 
 
 
Na tela seguinte selecione Other – Properties File, e após isso crie o arquivo com o 
nome hibernate. 
 
 
Insira o código abaixo: 
7 
 
hibernate.dialect org.hibernate.dialect.PostgreSQLDialect 
hibernate.connection.driver_class org.postgresql.Driver 
hibernate.connection.url jdbc:postgresql://localhost:5432/exemplo 
hibernate.connection.username postgres 
hibernate.connection.password postgres 
hibernate.show_sql false 
hibernate.format_sql false 
 
 Observe que neste arquivo são estabelecidos os parâmetros de configuração da 
conexão do aplicativo com o SGBD. As propriedades username e password definem o usuário 
e a senha de acesso ao banco de dados. 
1.3. Criando a Classe de Modelo (model) 
 No pacote model crie a classe Departamento, com um construtor padrão (vazio) e os 
seguintes atributos encapsulados: 
 id (Integer) 
 nome (String) 
 area (String) 
 
 
 
8 
 
 Os atributos podem ser encapsulados selecionando-se um deles com o botão esquerdo 
e utilizando-se o comando Refactor conforme a figura a seguir. 
 
Após isso é exibida a seguinte tela. 
9 
 
 
 
Agora, será necessário mapear a classe Departamento da aplicação à tabela 
departamento do SGBD. Isto é necessário para indicar qual(is) tabela(s) do banco de dados 
corresponde(m) à classe de entidade. Isto é feito por meio de uma anotação que indica essa 
correspondência. 
 Neste exemplo faremos o mapeamento por meio de anotações na classe. A figura a 
seguir apresenta parte do código. 
10 
 
 
 
 
 As anotações (precedidas por '@') indicam o mapeamento entre a classe e a tabela do 
banco de dados. Algumas importações do pacote javax.persistence serão necessárias neste 
ponto. 
 
 
 
 
 
11 
 
 
1.4. Construindo a Conexão 
 No pacote dao, crie a classe HibernateConfiguracao, com o seguinte código. 
public class HibernateConfiguracao { 
 private static SessionFactory sessionFactory; 
 public HibernateConfiguracao() { 
 } 
 public Session openSession() { 
 if (sessionFactory == null) { 
 criaSessionFactory(); 
 } 
 return sessionFactory.openSession(); 
 } 
 
 public void criaSessionFactory() { 
 Configuration configuration = new Configuration(); 
 configuration.addAnnotatedClass(Departamento.class); 
 ServiceRegistry serviceRegistry = 
new ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(). 
applySettings(configuration.getProperties()).build(); 
sessionFactory = configuration.buildSessionFactory(serviceRegistry); 
 
 } 
} 
Neste momento será necessário importar algumas classes do Hibernate. 
1.5. Criando a Classe dao 
 A classe da irá permitir o acesso do sistema ao SGBD configurado. Para tanto, iremos 
utilizar um dao Genérico que possui os métodos básicos de acesso a um banco de dados. 
 Incluir; 
 Alterar; 
 Excluir; 
 Consultar; 
 Listar. 
 Para a execução básicas destas operações, pode-se empregar estes métodos genéricos. 
Crie uma classe chamada DaoGenerico (no pacote dao), com o código exibido a seguir. 
public class DaoGenerico { 
 protected HibernateConfiguracao hibernateConfiguracao; 
 public DaoGenerico () { 
 hibernateConfiguracao = new HibernateConfiguracao();} 
public void gravar(Object obj) throws HibernateException { 
12 
 
 Session session = hibernateConfiguracao.openSession(); 
 Transaction transaction = session.beginTransaction(); 
 session.save(obj); 
 transaction.commit(); 
 session.close(); 
 } 
public void alterar(Object obj) throws HibernateException { 
 Session session = hibernateConfiguracao.openSession(); 
 Transaction transaction = session.beginTransaction(); 
 session.update(obj); 
 transaction.commit(); 
 session.close(); 
 } 
public void excluir(Object obj) throws HibernateException { 
 Session session = hibernateConfiguracao.openSession(); 
 Transaction transaction = session.beginTransaction(); 
 session.delete(obj); 
 transaction.commit(); 
 session.close(); 
 } 
public List carregarTudoOrdenado(Class clas, String ordem) throws 
HibernateException { 
 Session session = hibernateConfiguracao.openSession(); 
 Criteria criteria = session.createCriteria(clas); 
 criteria.addOrder(Order.asc(ordem)); 
 List lista = criteria.list(); 
 session.close(); 
 return lista; 
 } 
 
public Object carregarUm(int id, Class<?> clas) throws HibernateException { 
 Session session = hibernateConfiguracao.openSession(); 
 Transaction transaction = session.beginTransaction(); 
 Criteria criteria = session.createCriteria(clas); 
 criteria.add(Restrictions.eq("id", id)); 
 Object obj = criteria.uniqueResult(); 
 transaction.commit(); 
 session.close(); 
 return obj; 
 } 
} 
 No mesmo pacote, crie o DaoDepartamento, herdando do DaoGenerico e com um 
construtor próprio. 
1.6. Construindo o Controlador (Controller) 
 No pacote control, crie uma nova classe, chamada CtrManterDepartamento. Nesta 
classe crie um atributo utilizando o seguinte código: 
 DaoDepartamento acessohibernatedepto; 
 
 Após isso inclua o código a seguir. 
13 
 
 public CtrManterDepartamento() { 
acessohibernatedepto = new DaoDepartamento(); 
 } 
 
 public int gravarDepartamento(Departamento departamento) { 
 try { 
 acessohibernatedepto.gravar(departamento); 
 return 1; 
 } catch (HibernateException e) { 
 e.printStackTrace(); 
 return 2; 
 } 
 } 
 
 public List carregarDepartamentos() { 
 try { 
 return acessohibernatedepto.carregarTudoOrdenado(Departamento.class, 
"nome"); 
 } catch (HibernateException e) { 
 return null; 
 } 
 } 
 
 public boolean excluirDepartamento(Departamento departamento) { 
 try { 
 acessohibernatedepto.excluir(departamento); 
 return true; 
 } catch (HibernateException e) { 
 e.printStackTrace(); 
 return false; 
 } 
 } 
 
 public boolean alterarDepartamento(Departamento departamento) { 
 try { 
 acessohibernatedepto.alterar(departamento); 
 return true; 
 } catch (HibernateException e) { 
 e.printStackTrace(); 
 return false; 
 } 
 } 
 
1.7. Construindo o Formulário (View) 
 Num primeiro momento, iremos criar um formulário que permita somente a inclusão 
dos departamentos. Para isso, no pacote view, crie um novo JFrame, chamado 
FrmManterDepartamento. 
14 
 
 
 
 
15 
 
 
Insira um JButton “Incluir” (jBtnIncluir) e dois JtextField (jTxtNome, jTxtArea) para 
o nome e a área do departamento. Após isso, crie 2 atributos no código do formulário, 
conforme o apresentado abaixo. 
CtrManterDepartamento ctrManterDepartamento; 
Departamento depart; 
 Crie instâncias destes objetos na inicialização da tela. 
Agora, crie um evento para o botão (selecione com o botão esquerdo - Events – Mouse 
– mouseClicked) e insira o código a seguir no evento criado. 
 depart = new Departamento(); 
 
 depart.setNome(jTxtNome.getText()); 
 depart.setArea(jTxtArea.getText()); 
 if (ctrManterDepartamento.gravarDepartamento(depart) == 1) { 
 JOptionPane.showMessageDialog(null, "Objeto persistido"); 
 } else { 
 JOptionPane.showMessageDialog(null, "Objeto não persistido"); 
 } 
 
 
 
 
 
16 
 
 
 
A seguir, é mostrado um exemplo deste JFrame. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1.8. Construindo a Tela Inicial da Aplicação 
 No pacote padrão, crie mais um JFrame, chamado Principal, inclua nele um Jbutton 
(jBtnExibirDepartamento), e faça as seguintes alterações na classe: 
public Principal() { 
HibernateConfiguracao configuracao = new HibernateConfiguracao(); 
 configuracao.criaSessionFactory(); 
 initComponents(); 
} 
 
public static void main(String args[]) { 
Principal telaPrincipal = new Principal(); 
telaPrincipal.setVisible(true); 
 telaPrincipal.setExtendedState(MAXIMIZED_BOTH); 
} 
 
 Agora crie um evento actionPerformed no botão e insira o seguinte código. 
private void jBtnExibirDepartamentoActionPerformed 
(java.awt.event.ActionEvent evt) { 
 FrmManterDepartamento telaDepartamento = new 
FrmManterDepartamento(); 
 telaDepartamento.setVisible(true); 
 telaDepartamento.setLocationRelativeTo(this); 
 } 
Neste momento o aplicativo já deve permitir a inclusão de departamentos. Execute o 
programa para avaliar os resultados. Se desejar, inclua o código para limpar os campos se o 
departamento for inserido corretamente. 
 Deve-se também definir o JFrame principal como tela inicial da aplicação (Project 
17 
 
Properties – Run – Main Class). 
 
1.9. Listando os Objetos 
 Para permitir a visualização dos dados, insira um componente JList no formulário 
FrmManterDepartamento e faça as seguintes alterações: 
 Aumente a largura da lista; 
 Altere o nome para jLstDepartamentos; 
 Remova todos os itens de sua propriedade model; e 
 Altere o selectionMode para Single. 
 O formulário deve ficar com a seguinte aparência. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 A seguir, inclua um novo evento no JFrame (Window – windowActiveted), insira o 
código no evento criado e importe as classes necessárias. 
DefaultListModel listModel = new DefaultListModel(); 
List listDepartamento = new ArrayList(); 
listDepartamento = ctrManterDepartamento.carregarDepartamentos(); 
if (listDepartamento != null) { 
 Iterator i = listDepartamento.iterator(); 
 while (i.hasNext()) { 
 Departamento deptList = (Departamento) i.next(); 
 listModel.addElement(deptList); 
 } 
 jLstDepartamentos.setModel(listModel); 
} 
18 
 
 
 
 
 Insira o método abaixo na classe Departamento do pacote model. 
 public String toString() { 
 return this.getNome(); 
 } 
 Observe que a lista foi preenchida com objetos da classe departamento. Logo, a 
consulta aos dados de um objeto ficou muito mais simples. 
 Para exibir os dados de um objeto selecionado na lista, crie um novo evento para a 
lista (Mouse – mouseClicked) e acrescente o código a seguir ao evento: 
 depart = (Departamento) jLstDepartamentos.getSelectedValue(); 
 if (depart != null) { 
 jTxtNome.setText(depart.getNome()); 
 jTxtArea.setText(depart.getArea()); 
 } else { 
 JOptionPane.showMessageDialog(null, "Objeto não Encontrado!"); 
 } 
 Neste momento a execução do programa deverá permitir a inclusão dos objetos da 
classe departamento, e também a listagem e consulta dos mesmos. 
 
1.10. Excluindo os Objetos 
 Iremos agora permitir a exclusão de departamentos. Para tanto, inclua um novo 
Jbutton, altere sua propriedade Text para “Excluir” e sua propriedade Name para 
“jBtnExcluir”. 
 Após isso, crieum evento para o novo botão (Events – Mouse – mouseClicked) e insira 
o código abaixo. 
 depart = (Departamento) jLstDepartamentos.getSelectedValue(); 
 if (depart != null) { 
 if (ctrManterDepartamento.excluirDepartamento(depart)) { 
 JOptionPane.showMessageDialog(null, "Objeto Excluído"); 
 } else { 
 JOptionPane.showMessageDialog(null, "Objeto não excluído"); 
 } 
 } else { 
 JOptionPane.showMessageDialog(null, "Selecione o Objeto"); 
 } 
 Execute o programa e observe os resultados. Se desejar, limpe os campos da tela após 
a alteração e a exclusão do objeto. 
 
19 
 
 
1.11. Alterando Objetos 
 Agora vamos possibilitar a alteração de um objeto selecionado na lista. Para tanto, 
inclua um novo botão na tela, conforme exibido na figura abaixo. 
 Modifique sua propriedade texto para “Alterar”,sua propriedade Name para 
jBtnAlterar e crie um novo evento (Mouse – mouseClicked) para o novo botão. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Insira o código abaixo no evento criado para o botão. 
 depart = (Departamento) jLstDepartamentos.getSelectedValue(); 
 if (depart != null) { 
 depart.setNome(jTxtNome .getText()); 
 depart.setArea(jTxtArea .getText()); 
 
 if (ctrManterDepartamento.alterarDepartamento(depart)) { 
 JOptionPane.showMessageDialog(null, "Objeto persistido"); 
 
 } else { 
 JOptionPane.showMessageDialog(null, "Objeto não persistido"); 
 } 
 } else { 
 JOptionPane.showMessageDialog(null, "Objeto não localizado"); 
 }