1) O documento discute técnicas de programação para acessar bancos de dados usando JDBC, incluindo como configurar o acesso ao banco de dados, executar consultas SQL, e lidar com resultados e erros.
2) É explicado como configurar o driver JDBC, JNDI e conexão no Tomcat e como usar classes como Connection, Statement e ResultSet para executar consultas e processar resultados.
3) É destacada a importância de fechar corretamente os recursos abertos para evitar vazamentos de memória.
1. Acesso a Banco de Dados
JDBC
Técnicas de Programação
FA7
Prof.º Eduardo Mendes
2. Trabalhando
com Banco de Dados
Nesta aula
Criar um banco de dados e uma tabela de alunos
Configurar a aplicação para acessar o banco de
dados
JNDI, server.xml, web.xml
Criar uma classe que acesse o banco com a
configuração realizada
12. Java Database Connectivity
Conectividade a Bancos de Dados Java
Biblioteca
Acesso a bancos de dados por meio de Java
Desenvolvedores podem acessar bancos de dados
não importando quem é o distribuidor
Utilização de “driver”
13. Java Name and Directory Interface
JNDI
API Java padrão
para acessar
diretórios
Local
centralizado
Aplicação Java
pode recuperar
recursos
externos através
de um nome
14. Java Name and Directory Interface
Principais estruturas:
Principal método de Context:
lookup(“[recurso]”)
15. Configurando o acesso ao banco
via JNDI
Instale o driver JDBC do MySQL na pasta lib do
Tomcat
Configure um nome JNDI para o banco de dados
que aplicação deve acessar no arquivo server.xml
do tomcat.
Este arquivo se encontra na pasta conf
Configure sua aplicação para acessar o recurso
JNDI.
Faça isto no web.xml
19. Preparando uma classe para
acessar o Banco de Dados
Crie uma classe chamada AlunoDAO, no pacote
dao
DAO – Data Access Object
Dentro da classe crie um método chamado:
public void getAlunos() throws Exception
21. JDBC
Principais Classes
javax.sql.DataSource
Abrange os detalhes de como obter uma conexão para o
banco de dados
java.sql.Connection
Representa uma conexão com um banco de dados
java.sql.Statement
Fornece métodos para o desenvolvedor executar instruções
SQL
java.sql.ResultSet
Representa o resultado de uma instrução SQL de Pesquisa
22. javax.sql.DataSource
Uma interface definida na API
Modo recomendado para um desenvolvedor obter
um objeto Connection
Após obter uma instância de DataSource
É possível recuperar o objeto Connection
Como?
Chamar o método getConnection() em uma instância
de DataSource
23. Recuperando DataSource
O contexto JNDI abstrai os detalhes de conexão
com o recurso
Utilize o nome com o qual DataSource foi
configurado
ds = (DataSource) envCtx.lookup("jdbc/fa7");
Uma vez que se tenha uma instância DataSource
válida, obter uma conexão é:
Connection conn = ds.getConnection();
24. Obtendo um DataSource
e a conexão
initCtx = new InitialContext();
envCtx = (Context) initCtx.lookup("java:comp/env");
ds = (DataSource) envCtx.lookup("jdbc/fa7");
conn = ds.getConnection();
25. java.sql.Connection
Objetos da classe java.sql.Connection
Representam conexões atuais para o banco de
dados
A partir deste objeto é possível criar a classe
Statement
27. java.sql.Statement
Métodos
executeQuery
Executa comandos SELECT, retornando o resultado
de operações como um objeto ResultSet
executeUpdate
Executa comandos INSERT, UPDATE ou DELETE,
retornando o número de colunas afetadas como um
tipo int
28. Executando uma consulta
initCtx = new InitialContext();
envCtx = (Context) initCtx.lookup("java:comp/env");
ds = (DataSource) envCtx.lookup("jdbc/fa7");
conn = ds.getConnection();
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM alunos");
29. java.sql.ResultSet
Resultados de uma consulta no banco de dados
Um objeto ResultSet pode ser visualizado como
uma tabela
A informação é recuperada uma linha por vez
O objeto ResultSet mantém a linha corrente
Para percorrer as linhas da tabela em ResultSet,
usamos o método next()
30. Percorrendo os resultados
rs = stmt.executeQuery("SELECT * FROM alunos");
while (rs.next()) {
String alunoNome = rs.getString("nome");
int alunoIdade = rs.getInt("idade");
int alunoId = rs.getInt("id");
System.out.println(alunoId);
System.out.println(alunoNome);
System.out.println(alunoIdade);
}
31. Liberando Recursos do Sistema
Este é um passo muito importante que
freqüentemente é negligenciado após ter sido
completada
Deve ser feita explicitamente e é uma
responsabilidade do programador
Sem executar tal liberação, os recursos tomados
pela operação não podem ser usadas no futuro
Para aplicações muito grandes, isto rapidamente
resulta na perda de conexões disponíveis
32. Liberando Recursos do Sistema
Executada chamando o método close() disponíveis em
cada objeto das classes Connection, Statement, e
ResultSet
Existem uma ordem específica envolvida
O método close está definido para lançar uma
SQLException
Erros comuns dos desenvolvedores: colocar
simplesmente os métodos dentro do corpo do programa
Somente recorrer a condições de bem sucedidas
O código deve ser colocado dentro de uma cláusula
finally
33. Liberando Recursos do Sistema
} finally {
try {
if (rs != null)
rs.close();
} catch (SQLException e) {}
try {
if (stmt != null)
stmt.close();
} catch (SQLException e) {}
try {
if (conn != null)
conn.close();
} catch (SQLException e) {}
}
34. Prepared Statement
Classe que deriva de Statement
Tem performance melhor
Uma consulta pré-compilada
O Banco de Dados executa direto, sem ter que
compilar
É preferível usá-la quando a consulta deve ser
usada mais que uma vez
35. Criando um Objeto
PreparedStatement
Cria-se através de uma conexão, assim como o
Statement
Parâmetros são fornecidos em forma de “?”
Posteriormente serão substituídos por valores
37. Fornecendo os valores da
consulta
Os valores representados por “?” devem ser
informados
Métodos setXXX
Para int, setInt()
Para String setString()
Existe um método para cada tipo primitivo
declarado na linguagem JAVA
38. Fornecendo os valores da
consulta
PreparedStatement teste =
conn.prepareStatement(
“UPDATE alunos SET nome = ? WHERE id
= ?”);
teste.setString(1, “Dudu”);
teste.setInt(2, 1);
39. Como executar a consulta?
PreparedStatement teste =
conn.prepareStatement(
“UPDATE alunos SET nome = ? WHERE id
= ?”);
teste.setString(1, “Dudu”);
teste.setInt(2, 1);
teste.executeUpdate();
40. Usando um laço para alterar
PreparedStatement alterarAlunos;
String alterarString =
“UPDATE alunos SET nome = ? WHERE id = ?";
alterarAlunos = conn.prepareStatement(alterarString);
int [] alunosIds= {175, 150, 60, 155, 90};
String [] nomes = {“Eduardo", “Gustavo", “Odmir",
“Fernando", “Raphabs"};
int len = nomes.length;
for(int i = 0; i < len; i++) {
alterarAlunos.setInt(1, alunosIds[i]);
alterarAlunos.setString(2, nomes[i]);
alterarAlunos.executeUpdate();
}
41. Transações
Algumas vezes é necessário que certas consultas
só executem caso outras tenham sucesso
Uma transação pode ser vista como um conjunto
de consultas dependentes
42. Transações
con.setAutoCommit(false);
PreparedStatement alterarAluno =
con.prepareStatement( "UPDATE alunos SET nome = ?
WHERE id = ?");
alterarAluno.setInt(1,”Dudu”);
alterarAluno.setString(2, 1);
alterarAluno.executeUpdate();
PreparedStatement alterarIdade =
con.prepareStatement( "UPDATE alunos SET idade = idade
+ ? WHERE id LIKE ?");
alterarIdade.setInt(1, 1);
alterarIdade.setString(2, 1);
alterarIdade.executeUpdate();
con.commit();
con.setAutoCommit(true);