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

3. Conceitos
 Tabelas
 Linhas
 Campos
 Chaves primárias

4. Tabela típica de dados:
Agenda Telefônica

5. Cursos da FA7

7. No MySQL
CREATE DATABASE modulo3;
USE modulo3;
CREATE TABLE agendaTelefonica (
id INT PRIMARY KEY,
primeiroNome VARCHAR(15),
sobreNome VARCHAR (15),
email VARCHAR(20),
telefone VARCHAR(15)
);
DESCRIBE agendaTelefonica;

8. Inserindo Valores
INSERT INTO agendaTelefonica
VALUES(
0, ‘Eduardo', ‘Mendes',
‘eduardo@fa7.edu.br', '123567‘
);

9. Recuperando os dados
 Eu quero visualizar todos os registro
de uma tabela
SELECT * FROM nomeDaTabela;

10. No MySQL
SELECT * FROM agendaTelefonica;

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

16. Instalando o driver

17. Configurando o server.xml
<Context docBase="16102008" path="/16102008"
reloadable="true"
source="org.eclipse.jst.j2ee.server:16102008" >
<Resource name="jdbc/fa7"
auth="Container"
type="javax.sql.DataSource“
maxActive="100" maxIdle="30" maxWait="10000“
username="root" password=""
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/fa7"
/>
</Context>

18. Configurando o web.xml
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/fa7</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>

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

20. getAlunos()
Context initCtx = null;
Context envCtx = null;
DataSource ds = null;
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
initCtx = new InitialContext();
envCtx = (Context) initCtx.lookup("java:comp/env");

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

26. Obtendo um objeto Statement
initCtx = new InitialContext();
envCtx = (Context) initCtx.lookup("java:comp/env");
ds = (DataSource) envCtx.lookup("jdbc/fa7");
conn = ds.getConnection();
stmt = conn.createStatement();

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

36. Criando um Objeto
PreparedStatement
PreparedStatement teste =
conn.prepareStatement(
“UPDATE alunos SET nome = ? WHERE id = ?”);

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);