Introdução à Integração com Banco de Dados em Java
Bem-vindo à aula de Integração com Banco de Dados! Neste curso, você aprenderá a conectar aplicativos Java a bancos de dados relacionais, executar consultas SQL e gerenciar dados de forma eficiente. Uma habilidade fundamental para desenvolvedores de software.
Atividades Práticas
Laboratório — Integração com Banco de Dados (Java + JDBC)
Ambiente recomendado: VS Code + Java Extension Pack + Maven (ou Gradle). Para começar com menos atrito, use SQLite; depois, faça a extensão opcional para MySQL.
Exercício 0 — Preparação do projeto (10–15 min)
Objetivo: Deixar o projeto Java pronto com a dependência JDBC.
- Crie um projeto Maven (ex.:
lab-jdbc).
- No
pom.xml, adicione a dependência do SQLite JDBC:
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.40.1.0</version>
</dependency>
Alternativa (MySQL):mysql:mysql-connector-java:8.0.33.
Entrega: print do
pom.xml com a dependência adicionada e o projeto compilando.Exercício 1 — “Hello, DB!”: conexão com o SQLite (10–15 min)
Objetivo: Abrir e fechar uma conexão com o SQLite.
- Crie o arquivo
ConexaoDB.java:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConexaoDB {
private static final String URL = "jdbc:sqlite:./loja.db"; // cria o arquivo no diretório do projeto
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(URL);
}
public static void main(String[] args) {
try (Connection conn = getConnection()) { // try-with-resources fecha automático
System.out.println("Conexão estabelecida!");
} catch (SQLException e) {
System.out.println("Erro ao conectar: " + e.getMessage());
}
}
}
String de conexão SQLite e uso de try-with-resources conforme a aula.
Teste: rode a classe; confirme a mensagem e a criação do arquivo
loja.db. Entrega: print do terminal com “Conexão estabelecida!”.Exercício 2 — Criando o esquema (DDL) (15–20 min)
Objetivo: Criar as tabelas
clientes e pedidos (com chave estrangeira).- Crie
CriaSchema.java:
import java.sql.*;
public class CriaSchema {
public static void main(String[] args) {
String sqlClientes = """
CREATE TABLE IF NOT EXISTS clientes (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nome TEXT NOT NULL,
email TEXT UNIQUE,
telefone TEXT,
data_cadastro DATE
);
""";
String sqlPedidos = """
CREATE TABLE IF NOT EXISTS pedidos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
cliente_id INTEGER,
data_pedido DATE,
valor DECIMAL(10,2),
FOREIGN KEY (cliente_id) REFERENCES clientes(id)
);
""";
try (Connection conn = ConexaoDB.getConnection();
Statement st = conn.createStatement()) {
st.execute(sqlClientes);
st.execute(sqlPedidos);
System.out.println("Tabelas criadas/validadas com sucesso.");
} catch (SQLException e) {
System.out.println("Erro ao criar tabelas: " + e.getMessage());
}
}
}
Estruturas de clientes e pedidos com chave estrangeira, como no material.
Entrega: print da execução + print do esquema visto no DB Browser (opcional).
Exercício 3 — Inserção segura com PreparedStatement (20–25 min)
Objetivo: Inserir registros em
clientes com parâmetros e em lote.- Crie
InsereClientes.java:
import java.sql.*;
import java.util.List;
public class InsereClientes {
public static void main(String[] args) {
List<String[]> dados = List.of(
new String[]{"Maria Silva", "maria@email.com", "11999887766"},
new String[]{"João Souza", "joao@email.com", "11999995555"}
);
String sql = "INSERT INTO clientes (nome, email, telefone, data_cadastro) VALUES (?, ?, ?, date('now'))";
try (Connection conn = ConexaoDB.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
conn.setAutoCommit(false);
for (String[] d : dados) {
ps.setString(1, d[0]);
ps.setString(2, d[1]);
ps.setString(3, d[2]);
ps.addBatch();
}
ps.executeBatch();
conn.commit();
System.out.println("Clientes inseridos com sucesso.");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
PreparedStatement é recomendado e protege contra SQL Injection.
Entrega: print do terminal + SELECT mostrando os registros (pode usar o Exercício 4).
Exercício 4 — Consultas (SELECT) com filtros e ordenação (20 min)
Objetivo: Ler dados e exibir no console com WHERE/ORDER BY/LIMIT.
- Crie
ListaClientes.java:
import java.sql.*;
public class ListaClientes {
public static void main(String[] args) {
String sql = """
SELECT id, nome, email
FROM clientes
WHERE nome LIKE 'M%'
ORDER BY id DESC
LIMIT 10
""";
try (Connection conn = ConexaoDB.getConnection();
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(sql)) {
while (rs.next()) {
System.out.printf("[%d] %s <%s>%n",
rs.getInt("id"),
rs.getString("nome"),
rs.getString("email"));
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Uso de SELECT/WHERE/ORDER BY/LIMIT conforme a sintaxe apresentada.
Entrega: print do console com a listagem.
Exercício 5 — UPDATE e DELETE com segurança (20–25 min)
Objetivo: Atualizar telefone e remover um cliente sempre com WHERE.
AtualizaCliente.java:
import java.sql.*;
public class AtualizaCliente {
public static void main(String[] args) {
String sql = "UPDATE clientes SET telefone = ? WHERE id = ?";
try (Connection conn = ConexaoDB.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setString(1, "11999998888");
ps.setInt(2, 1);
int linhas = ps.executeUpdate();
System.out.println("Linhas atualizadas: " + linhas);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
RemoveCliente.java:
import java.sql.*;
public class RemoveCliente {
public static void main(String[] args) {
String sql = "DELETE FROM clientes WHERE id = ?";
try (Connection conn = ConexaoDB.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setInt(1, 2);
int linhas = ps.executeUpdate();
System.out.println("Linhas removidas: " + linhas);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Nunca executeDELETEsemWHERE— isso apaga todos os registros. Faça SELECT antes para conferir e, se possível, limite a operação. p
Entrega: prints das saídas + SELECT comprovando as mudanças.
Exercício 6 — Transações (commit/rollback) (25–30 min)
Objetivo: Garantir atomicidade em duas operações relacionadas.
- Crie
PedidoTransacional.javapara inserir um cliente e um pedido “na mesma transação”:
import java.sql.*;
public class PedidoTransacional {
public static void main(String[] args) {
String insereCliente = "INSERT INTO clientes (nome, email, telefone, data_cadastro) VALUES (?, ?, ?, date('now'))";
String inserePedido = "INSERT INTO pedidos (cliente_id, data_pedido, valor) VALUES (?, date('now'), ?)";
try (Connection conn = ConexaoDB.getConnection()) {
conn.setAutoCommit(false); // Início da transação
// 1) Cliente
int novoClienteId;
try (PreparedStatement ps = conn.prepareStatement(insereCliente, Statement.RETURN_GENERATED_KEYS)) {
ps.setString(1, "Cliente Tx");
ps.setString(2, "ctx@example.com");
ps.setString(3, "11911112222");
ps.executeUpdate();
try (ResultSet keys = ps.getGeneratedKeys()) {
keys.next();
novoClienteId = keys.getInt(1);
}
}
// 2) Pedido vinculado
try (PreparedStatement ps = conn.prepareStatement(inserePedido)) {
ps.setInt(1, novoClienteId);
ps.setBigDecimal(2, new java.math.BigDecimal("199.90"));
ps.executeUpdate();
}
conn.commit();
System.out.println("Transação confirmada.");
} catch (SQLException e) {
e.printStackTrace();
// Em produção: tentar rollback dentro de outro try/catch
}
}
}
A aula destaca o uso de transações para garantir atomicidade (ACID) e consistência.
Desafio rápido: force um erro entre as duas etapas (ex.: valor nulo onde não pode) e comprove que nada é persistido se ocorrer
rollback().Entrega: prints mostrando o commit bem-sucedido e o comportamento quando há erro/rollback.
Exercício 7 — (Opcional) Conectar ao MySQL (20–25 min)
Objetivo: Repetir o Exercício 1 no MySQL.
- Garanta um servidor MySQL local ativo e crie o banco:
CREATE DATABASE meubanco;
- Crie
ConexaoMySQL.java:
import java.sql.*;
public class ConexaoMySQL {
public static Connection getConnection() throws SQLException {
String url = "jdbc:mysql://localhost:3306/meubanco";
String user = "root";
String pass = "sua_senha";
return DriverManager.getConnection(url, user, pass);
}
public static void main(String[] args) {
try (Connection conn = getConnection()) {
System.out.println("Conectado ao MySQL!");
} catch (SQLException e) {
System.out.println("Erro: " + e.getMessage());
}
}
}
Use a URLjdbc:mysql://localhost:3306/meubanco, com usuário/senha válidos. O banco deve existir antes da conexão.
Entrega: print do terminal com “Conectado ao MySQL!”.
Exercício 8 — (Bônus) Mini-DAO de
Cliente (30–40 min)Objetivo: Encapsular acesso a dados. Crie
ClienteDAO com: salvar(Cliente), listar(), buscarPorId(int), atualizarTelefone(int,String), remover(int). Implemente com PreparedStatement, retorne listas/objetos e trate exceções de maneira adequada.Entrega: repositório/projeto com a classe DAO + uma classe
Main de demonstração.Erros comuns & dicas rápidas
- Driver ausente ou dependência errada no
pom.xml.
- Caminho do SQLite inválido (prefira
jdbc:sqlite:./arquivo.db).
- Esquecer
WHEREemUPDATE/DELETE(risco de alterar/apagar tudo).
- Não fechar recursos — use try-with-resources.
- Achar que
Statementé “igual” aPreparedStatement(este previne SQL Injection e pode otimizar).
Objetivo da Aula
Ao final desta aula, você será capaz de:
Compreender os conceitos fundamentais de bancos de dados relacionais e sua aplicação em sistemas modernos
Configurar e utilizar a API JDBC (Java Database Connectivity) em projetos Java
Implementar conexões entre aplicações Java e bancos SQLite/MySQL
Realizar operações básicas de consulta e manipulação de dados através de código Java
Esta aula combina teoria e prática, fornecendo base sólida para implementação em projetos reais.
O que é Banco de Dados Relacional?
Um banco de dados relacional é um tipo de banco de dados que armazena e fornece acesso a pontos de dados relacionados entre si. Baseia-se no modelo relacional, uma forma intuitiva de representar dados em tabelas.
Neste modelo, os dados são organizados em tabelas (também chamadas de relações), que consistem em linhas e colunas. Cada linha representa um registro único (ou tupla), enquanto as colunas representam os atributos desse registro.
Exemplo: Uma tabela "Alunos" pode conter colunas como ID, Nome, Email e Telefone, onde cada linha representa um aluno específico com seus respectivos dados.
Introdução ao JDBC
O que é JDBC?
JDBC (Java Database Connectivity) é uma API Java que permite a conexão e interação com bancos de dados relacionais a partir de aplicações Java.
Para que serve?
- Estabelecer conexões com bancos de dados
- Enviar comandos SQL para o banco
- Processar resultados das consultas
- Gerenciar transações
JDBC é independente de banco de dados - o mesmo código Java pode funcionar com diferentes SGBDs apenas trocando o driver.
Instalando o VS Code para Java
Extensões Recomendadas
- Java Extension Pack: Pacote completo de ferramentas Java
- Language Support for Java: Suporte à linguagem e depuração
- Maven for Java: Gerenciamento de dependências
- Java Test Runner: Execução de testes unitários
- Database Client: Visualização e edição direta de bancos
O VS Code oferece um ambiente leve e personalizável para desenvolvimento Java, com recursos de autocompletar, refatoração e depuração.
UPDATE – Atualização de Dados
Sintaxe
UPDATE tabela
SET coluna1 = valor1, coluna2 = valor2
WHERE condição;Exemplos
-- Atualizar telefone de um cliente
UPDATE clientes
SET telefone = '11999998888'
WHERE id = 1;
-- Aumentar preço de produtos em 10%
UPDATE produtos
SET preco = preco * 1.10
WHERE categoria = 'Eletrônicos';
Cuidados Importantes
- Sempre use WHERE: Sem WHERE, todas as linhas serão atualizadas
- Teste primeiro: Use SELECT para verificar quais registros serão afetados
- Backup: Faça backup antes de operações em massa
- Transações: Use transações para garantir atomicidade