JDBC
CRIANDO O BANCO DE DADOS:
•
Siga as instruções para instalar o banco de dados H2 e criar a tabela Alunos.
CRIANDO O PROJETO JAVA PARA DESKTOP:
•
Crie um projeto Java chamado Prograd
•
Crie um pacote chamado br.edu.ufabc.prograd.modelo
•
Dentro do pacote que você acabou de criar, crie uma classe chamada Aluno que deve ter o
seguinte código:
package br.edu.ufabc.prograd.modelo;
public class Aluno {
}
1
private
private
private
private
Long id;
String nome;
String email;
String endereco;
Observe que criamos o atributo id do tipo Long não do tipo long, porque Long inicia o
atributo com valor default null. Fazemos assim para não dar erro na inserção do banco
de dados.
2
Vamos transformar a classe Aluno em um javabean. Javabeans são classes que possuem
o construtor sem argumentos e métodos de acesso do tipo get e set. Para fazer isso de
forma automática no Eclipse, use o atalho ctrl + 3 e digite generate. Dentre as opções
trazidas, selecione Generate Getters and Setters. Na janela que abrir, selecione todos
os atributos.
3
Crie um pacote chamado br.edu.ufabc.prograd.testes
4
Dentro do pacote recém-criado, crie uma classe chamada CriaAluno que deve ter o
seguinte código:
package br.edu.ufabc.prograd.testes;
import br.edu.ufabc.prograd.modelo.Aluno;
public class CriaAluno
{
public static void main(String[] args) throws SQLException {
Aluno aluno = new Aluno();
aluno.setNome("Jack");
aluno.setEmail("[email protected]");
aluno.setEndereco("Av. dos Estados, 5001");
aluno.setId((long) 3); // se essa conversão de tipo (casting)
der erro no Java 1.8, modifique o comando para: aluno.setId(new Long(3));
System.out.println(aluno.getNome());
System.out.println(aluno.getEmail());
System.out.println(aluno.getEndereco());
}
System.out.println(aluno.getId());
}
CONECTANDO O BANCO DE DADOS AO PROJETO JAVA:
•
Crie um pacote que será responsável pelas conexões com o BD:
br.edu.ufabc.prograd.jdbc
•
JDBC (Java DataBase Connectivity): conjunto de interfaces bem definidas dentro do pacote
java.sql;
•
driver JDBC: classes concretas que fazem ponte entre API JDBC e o BD;
•
no pacote br.edu.ufabc.prograd.jdbc, crie uma classe chamada ConnectionFactory com o
código:
package br.edu.ufabc.prograd.jdbc;
public class ConnectionFactory {
public Connection getConnection(){
System.out.println("Conectando ao banco de dados");
try {
// a linha abaixo não é mais necessária a partir do JDBC 4 (Java 6)
//Class.forName("org.h2.Driver");
return
DriverManager.getConnection("jdbc:h2:tcp://localhost/~poo","admin","admin");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
• adicione os imports necessários (java.sql.Connection e java.sql.DriverManager);
•
adicione o driver do H2 (um arquivo JAR) contendo a implementação JDBC do H2 ao
classpath do projeto. O driver do H2 chama-se h2-1.4.182.jar e encontra-se dentro da pasta
h2, pasta bin. Para incluir o driver do banco de dados: clique direito sobre o projeto, opção
Build Path -> Configure Build Path -> Libraries -> Add External JARs
•
teste a conexão na classe CriaAluno com o código:
// testando conexão
Connection connection = new ConnectionFactory().getConnection();
System.out.println("Conexão estabelecida");
connection.close();
•
sempre tratar exceções e sempre lembrar de fechar conexões do BD;
•
importância de criar uma fábrica de conexões: um único lugar para mudar, caso
necessário; possibilidade de criar pooling de conexões; seguimos padrões de projeto a
respeito de encapsular construção de objetos complicados (livro Padrões de Projeto da Gang
of four);
ACESSANDO E MODIFICANDO OS DADOS DO BANCO DE DADOS (INSERIR):
•
Crie um pacote que será responsável por objetos de acessos aos dados (DAO - Data Access
Object): br.edu.ufabc.prograd.dao
•
nesse pacote, crie um Javabean AlunoDAO;
•
lembre-se de importar a classe java.sql (cuidado para não confundir com a classe
com.sql);
•
coloque a conexão com o banco de dados no construtor do AlunoDAO:
public class AlunoDAO {
private Connection connection;
public AlunoDAO() {
this.connection = new ConnectionFactory().getConnection();
}
•
Na classe AlunoDAO, implemente a inserção de registros:
public void insere(Aluno aluno) {
(?,?,?)";
String sql = "insert into alunos (nome,email,endereco) values
try { // prepared statement para inserção
PreparedStatement stmt = connection.prepareStatement(sql);
// seta valores
stmt.setString(1, aluno.getNome());
stmt.setString(2, aluno.getEmail());
stmt.setString(3, aluno.getEndereco());
//executa
stmt.execute();
}
•
// fecha statement
stmt.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
modifique a classe CriaAluno, acrescentando um código para testar o método de inserção:
// gravando registro
AlunoDAO dao = new AlunoDAO();
dao.insere(aluno);
System.out.println("Gravado!");
•
Quais são os problemas com a SQL abaixo?
String
sql
=
"insert
into
alunos
('"+nome+"','"+email+"'+'"+endereco+"')";
1. difícil de ler;
•
mais provável de ocorrer erros;
(nome,email,endereco)
values
•
preconceito contra Joana D'Arc;
•
SQL Injection: técnica usada para atacar aplicações orientadas a dados. Ilustração:
http://xkcd.com/327/
•
é necessário sanitizar as entradas do BD: tratar entradas (caracteres especiais, etc);
•
mais genérico e mais seguro:
String sql = "insert into alunos (nome,email,endereco) values (?,?,?)";
1. PreparedStatement: interface para executar as cláusulas, faz sanitização das entradas do BD;
ACESSANDO E MODIFICANDO OS DADOS DO BANCO DE DADOS (REMOVER,
ALTERAR E LISTAR):
•
Implemente a remoção de registros:
public void remove(Aluno aluno) {
try {
PreparedStatement stmt = connection.prepareStatement("delete
from alunos where id=?");
stmt.setLong(1, aluno.getId());
stmt.execute();
stmt.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
•
modifique a classe CriaAluno, acrescentando um código para testar o método de remoção
(não esqueça de setar o id do registro a ser modificado):
// removendo registro
AlunoDAO dao = new AlunoDAO();
dao.remove(aluno);
System.out.println("Removido!");
•
implemente a alteração de registros:
public void altera(Aluno aluno) {
id=?";
String sql = "update alunos set nome=?, email=?, endereco=? where
try {
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, aluno.getNome());
stmt.setString(2, aluno.getEmail());
stmt.setString(3, aluno.getEndereco());
stmt.setLong(4, aluno.getId());
stmt.execute();
stmt.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
•
modifique a classe CriaAluno, acrescentando um código para testar o método de alteração
(não esqueça de setar o id do registro a ser modificado):
// alterando registro
AlunoDAO dao = new AlunoDAO();
dao.altera(aluno);
System.out.println("Alterado!");
•
implemente a listagem dos registros:
public List<Aluno> getLista() { // importar java.util
List<Aluno> alunos = new ArrayList<Aluno>();
PreparedStatement stmt;
try {
stmt = this.connection.prepareStatement("select * from alunos
order by nome");
ResultSet rs = stmt.executeQuery(); // importar java.sql
while (rs.next()) {
Aluno aluno = new Aluno();
aluno.setId(rs.getLong("id"));
aluno.setNome(rs.getString("nome"));
aluno.setEmail(rs.getString("email"));
aluno.setEndereco(rs.getString("endereco"));
alunos.add(aluno);
}
rs.close();
stmt.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
return alunos;
}
•
modifique a classe CriaAluno, acrescentando um código para testar o método de listagem:
// listando registros
AlunoDAO dao = new AlunoDAO();
List<Aluno> alunos = dao.getLista();
for (Aluno aluno1 : alunos){
System.out.println("Nome: "+aluno1.getNome()+" Email: "+aluno1
.getEmail()+" Endereço: "+ aluno1.getEndereco());
}
•
Use os métodos criados para inserir, remover, alterar e listar para fazer testes com o banco
de dados através da aplicação Java. Usando o comando SQL select, cheque no BD as
alterações realizadas.