O documento descreve como conectar programas Java a bancos de dados usando padrões Factory e DAO. Ele cria um banco de dados MySQL, define classes para acessar e manipular dados, e fornece um exemplo conectando-se ao banco de dados, inserindo, atualizando e listando registros.

1. COMO CONECTAR PROGRAMAS EM LINGUAGEM JAVA A BASES DE DADOS
Henrique Fernandes da Silva
1 INTRODUÇÃO
Estarei tratando aqui, como podemos utilizar a linguagem java, para acessar bancos de
dados. Os conceitos aqui discutidos, podem ser usados para criar aplicações, que acessem
diferentes base de dados, desde banco de dados relacionais, banco de dados orientados a
objetos ou até arquivos em textos plano. Utilizaremos os padrões de projeto Factory com
DAO(Data Access Object).
Nos próximos passos utilizaremos o Mysql Server.
1.1 Criando um banco de dados no Mysql Server
Os passos a seguir mostram como criar um banco de dados e uma tabela no Mysql
Server.
Abra o terminal e logue no Mysql server, digitando o comando abaixo, substituindo o
[usuario] por seu nome de usuário mysql:
mysql -p -u [usuario]
Criando o Banco de dados no Mysql Server:
CREATE DATABASE produtosdb;
Selecionando o Banco de dados no Mysql Server:
use produtosdb;
Criando a tabela produto:
CREATE TABLE produto (

2. id INT(4) AUTO_INCREMENT NOT NULL,
descricao VARCHAR(255),
preco DECIMAL(6,2),
PRIMARY KEY(id)
);
2 DIAGRAMA DE CLASSE DO PROJETO
O diagrama a seguir descreve os detalhes de como será feito o projeto usando a
UML(Linguagem de Modelagem Unificada em inglês). Veja a figura a seguir:
Figura 1: Diagrama de classes.
2.1 Estrutura do projeto Java

3. Figura 2: Estrutura do projeto.
2.2 Código das classes do projeto
A seguir veremos a implementação do diagrama de classes da Figura 1.
Classe ou entidade ou objeto de transferência Produto:
package dto;
public class Produto {
private int id;
private String descricao;
private double preco;
public Produto() { }
public Produto(int id, String descricao, double preco) {
this.id = id;
this.descricao = descricao;
this.preco = preco;
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return this.id;
}

4. public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getDescricao() {
return this.descricao;
}
public void setPreco(double preco) {
this.preco = preco;
}
public double getPreco() {
return this.preco;
}
@Override
public String toString() {
return "nId: " + this.getId() +
"nDescricao: " + this.getDescricao() +
"nPreco de venda: " + this.getPreco();
}
}
Enumeração Banco para definir os banco de dados suportados pelo projeto:
package factory;
public enum Banco {
MYSQL,
MONGODB,
TXTFILE
}
FactoryPessoaDao responsável por criar o banco de dados:
package factory;
import dao.InterfacePessoaDao;
import dao.MysqlDao;
public class FactoryPessoaDao {
// Metodo responsavel por criar o banco de dados.
public static InterfacePessoaDao criarBanco(Banco banco) {
InterfacePessoaDao dao = null;
switch (banco) {
case MYSQL:
dao = new MysqlDao();
break;
case MONGODB:
// TODO

5. break;
case TXTFILE:
// TODO
break;
}
return dao;
}
}
InterfacePessoaDao interface responsável por definir, o que uma classe dao
deve implementar:
package dao;
import java.util.ArrayList;
// Importando a Classe Produto
import dto.Produto;
public interface InterfacePessoaDao {
boolean inserir(Produto produto);
boolean atualizar(Produto produto);
boolean excluir(Produto produto);
ArrayList<Produto> todosOsProdutos();
}
MysqlDao implementação de classe de acesso a dados para banco Mysql:
package dao;
import java.util.ArrayList;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import dto.Produto;
public class MysqlDao implements InterfacePessoaDao {
String usuario = "seu usuario";
String senha = "sua senha";
String url = "jdbc:mysql://localhost/produtosdb";
@Override
public boolean inserir(Produto produto) {
// Se a operação teve sucesso.
boolean isSucesso = false;
String sql = "INSERT INTO produto(descricao, preco)

6. values(?, ?)";
Connection conexao;
PreparedStatement stm;
try {
conexao = DriverManager.getConnection(url, usuario,
senha);
stm = conexao.prepareStatement(sql);
stm.setString(1, produto.getDescricao());
stm.setDouble(2, produto.getPreco());
stm.executeUpdate();
isSucesso = true;
stm.close();
conexao.close();
} catch(SQLException erro) {
System.out.println("Erro SQL: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
} catch(Exception erro) {
System.out.println("Erro: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
}
return isSucesso;
}
@Override
public boolean atualizar(Produto produto) {
// Se a operação teve sucesso.
boolean isSucesso = false;
String sql = "UPDATE produto SET descricao=?, preco=? WHERE
id=?";
Connection conexao;
PreparedStatement stm;
try {
conexao = DriverManager.getConnection(url, usuario,
senha);
stm = conexao.prepareStatement(sql);
stm.setString(1, produto.getDescricao());
stm.setDouble(2, produto.getPreco());
stm.setInt(3, produto.getId());
stm.executeUpdate();
isSucesso = true;
stm.close();
conexao.close();
} catch(SQLException erro) {
System.out.println("Erro SQL: n" + erro.getMessage());

7. // Pode-se utilizar estes try para guardar erros em
arquivos de log.
} catch(Exception erro) {
System.out.println("Erro: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
}
return isSucesso;
}
@Override
public boolean excluir(Produto produto) {
// Se a operação teve sucesso.
boolean isSucesso = false;
String sql = "DELETE FROM produto WHERE id=?";
Connection conexao;
PreparedStatement stm;
try {
conexao = DriverManager.getConnection(url, usuario,
senha);
stm = conexao.prepareStatement(sql);
stm.setInt(1, produto.getId());
stm.executeUpdate();
isSucesso = true;
stm.close();
conexao.close();
} catch(SQLException erro) {
System.out.println("Erro SQL: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
} catch(Exception erro) {
System.out.println("Erro: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
}
return isSucesso;
}
@Override
public ArrayList<Produto> todosOsProdutos() {
ArrayList<Produto> produtos = new ArrayList<>();
String sql = "SELECT * FROM produto";
Connection conexao;
PreparedStatement stm;
try {
conexao = DriverManager.getConnection(url, usuario,
senha);

8. stm = conexao.prepareStatement(sql);
ResultSet rs = stm.executeQuery();
while(rs.next()) {
produtos.add(
new Produto(
rs.getInt(1),
rs.getString(2),
rs.getDouble(3))
);
}
} catch(SQLException erro) {
System.out.println("Erro SQL: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
} catch(Exception erro) {
System.out.println("Erro: n" + erro.getMessage());
// Pode-se utilizar estes try para guardar erros em
arquivos de log.
}
return produtos;
}
}
MainPointer utilizando os dao's e factory's. Esta classe possui um ponto
principal de execução o método main():
package app;
import dto.Produto;
import factory.Banco;
import factory.FactoryPessoaDao;
import dao.InterfacePessoaDao;
public class MainPointer {
public static void main(String[] args) {
// Criando acesso ao banco mysql.
InterfacePessoaDao dao =
FactoryPessoaDao.criarBanco(Banco.MYSQL);
// Criando um produto 1
Produto produto1 = new Produto();
// produto1.setId(1);
produto1.setDescricao("Pó de Pilim Pim Pim");
produto1.setPreco(400.32);
// Inserindo os produto 1
dao.inserir(produto1);
System.out.println("Inserido!n");
// Atualizando

9. produto1 = new Produto();
produto1.setId(1);
produto1.setDescricao("Pó de chulé");
produto1.setPreco(4003.32);
dao.atualizar(produto1);
// Exluindo
dao.atualizar(produto1);
// Listando produtos
System.out.println("Todos os Produtos na Base de Dados.");
for (Produto p : dao.todosOsProdutos()) {
System.out.println(p.toString());
}
}
}
CONCLUSÃO
Utilizando os padrões de projeto Factory com DAO(Data Access Object). Podemos
criar aplicações que podem acessar muitos banco de dados. Trabalhar com interface é um
ponte chave, pois, interfaces possibilitam que os tipos possam ser definidos em tempo de
execução. Usando Factory podemos definir que apenas a Factory, seja responsável por
instanciar o banco evitando assim, código macarrônico e com alto acoplamento.