JDBC

CRIANDO O BANCO DE DADOS:

Siga as instrues 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 cdigo:
package br.edu.ufabc.prograd.modelo;
public class Aluno {

private
private
private
private

Long id;
String nome;
String email;
String endereco;

Observe que criamos o atributo id do tipo Long no do tipo long, porque Long inicia o
atributo com valor default null. Fazemos assim para no dar erro na insero do banco
de dados.

Vamos transformar a classe Aluno em um javabean. Javabeans so classes que possuem

o construtor sem argumentos e mtodos de acesso do tipo get e set. Para fazer isso de
forma automtica no Eclipse, use o atalho ctrl + 3 e digite generate. Dentre as opes
trazidas, selecione Generate Getters and Setters. Na janela que abrir, selecione todos
os atributos.

Crie um pacote chamado br.edu.ufabc.prograd.testes

Dentro do pacote recm-criado, crie uma classe chamada CriaAluno que deve ter o
seguinte cdigo:

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("jack@gmail.com");
aluno.setEndereco("Av. dos Estados, 5001");
aluno.setId((long) 3); // se essa converso 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 responsvel pelas conexes 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

cdigo:

package br.edu.ufabc.prograd.jdbc;
public class ConnectionFactory {
public Connection getConnection(){
System.out.println("Conectando ao banco de dados");
try {
// a linha abaixo no mais necessria 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 necessrios (java.sql.Connection e java.sql.DriverManager);

adicione o driver do H2 (um arquivo JAR) contendo a implementao 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, opo
Build Path -> Configure Build Path -> Libraries -> Add External JARs

teste a conexo na classe CriaAluno com o cdigo:

// testando conexo
Connection connection = new ConnectionFactory().getConnection();
System.out.println("Conexo estabelecida");
connection.close();

sempre tratar excees e sempre lembrar de fechar conexes do BD;

importncia de criar uma fbrica de conexes: um nico lugar para mudar, caso
necessrio; possibilidade de criar pooling de conexes; seguimos padres de projeto a
respeito de encapsular construo de objetos complicados (livro Padres de Projeto da Gang
of four);

ACESSANDO E MODIFICANDO OS DADOS DO BANCO DE DADOS (INSERIR):

Crie um pacote que ser responsvel 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 no confundir com a classe

com.sql);

coloque a conexo 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 insero de registros:

public void insere(Aluno aluno) {

(?,?,?)";

String sql = "insert into alunos (nome,email,endereco) values

try { // prepared statement para insero
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 cdigo para testar o mtodo de insero:

// gravando registro
AlunoDAO dao = new AlunoDAO();
dao.insere(aluno);
System.out.println("Gravado!");

Quais so os problemas com a SQL abaixo?

String
sql
=
"insert
into
alunos
('"+nome+"','"+email+"'+'"+endereco+"')";

1. difcil de ler;

mais provvel de ocorrer erros;

(nome,email,endereco)

values

preconceito contra Joana D'Arc;

SQL Injection: tcnica usada para atacar aplicaes orientadas a dados. Ilustrao:
http://xkcd.com/327/

necessrio sanitizar as entradas do BD: tratar entradas (caracteres especiais, etc);

mais genrico e mais seguro:

String sql = "insert into alunos (nome,email,endereco) values (?,?,?)";

1. PreparedStatement: interface para executar as clusulas, faz sanitizao das entradas do BD;
ACESSANDO E MODIFICANDO OS DADOS DO BANCO DE DADOS (REMOVER,
ALTERAR E LISTAR):

Implemente a remoo 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 cdigo para testar o mtodo de remoo

(no esquea de setar o id do registro a ser modificado):
// removendo registro
AlunoDAO dao = new AlunoDAO();
dao.remove(aluno);
System.out.println("Removido!");

implemente a alterao 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 cdigo para testar o mtodo de alterao

(no esquea 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 cdigo para testar o mtodo 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()+" Endereo: "+ aluno1.getEndereco());
}

Use os mtodos criados para inserir, remover, alterar e listar para fazer testes com o banco
de dados atravs da aplicao Java. Usando o comando SQL select, cheque no BD as
alteraes realizadas.