Aula 6 - Introdução à Integração com Banco de Dados

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.
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.
Estrutura da Aula
1
Parte Teórica (1h)
Conceitos fundamentais de bancos relacionais, SQL e JDBC
Fundamentos de bancos de dados relacionais
Introdução à linguagem SQL
Arquitetura e componentes JDBC
2
Parte Prática (3h)
Implementação de código e exercícios
Configuração do ambiente de desenvolvimento
Implementação de conexões com bancos de dados
Criação de consultas e manipulação de dados
Exercícios práticos e resolução de problemas
Ferramentas Necessárias: VS Code com extensões Java, Driver JDBC, SQLite/MySQL
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.
Características do Banco Relacional
Esquema Definido
Estrutura rígida com tipos de dados predefinidos para cada coluna. Garante consistência e integridade.
Chaves e Relacionamentos
Chaves primárias identificam registros únicos. Chaves estrangeiras estabelecem relacionamentos entre tabelas.
Normalização
Processo de organização de dados para reduzir redundância e melhorar a integridade dos dados.
Conformidade ACID
Atomicidade, Consistência, Isolamento e Durabilidade - propriedades que garantem transações confiáveis.
Essas características tornam os bancos relacionais ideais para aplicações que necessitam de integridade de dados e relacionamentos complexos, como sistemas empresariais, financeiros e de gestão.
Diferença para Outros Bancos de Dados
Bancos Relacionais
Esquema fixo e predefinido
Dados organizados em tabelas
Linguagem SQL padronizada
Excelente para relações complexas
Garantias transacionais fortes (ACID)
Escalabilidade vertical
Bancos NoSQL
Esquema flexível ou inexistente
Diversos formatos: documentos, grafos, chave-valor
Linguagens de consulta específicas
Melhor para dados não estruturados
Consistência eventual (BASE)
Escalabilidade horizontal
A escolha entre relacional e não-relacional depende das necessidades específicas do projeto, volume de dados, requisitos de consistência e padrões de acesso.
Exemplos de Bancos Relacionais
MySQL
Sistema de código aberto, popular para aplicações web. Fácil de usar, possui excelente documentação e grande comunidade. Ideal para startups e projetos de médio porte.
SQLite
Banco embutido, sem servidor. Perfeito para aplicações locais e móveis. Arquivos únicos contendo todo o banco, facilmente portáveis entre sistemas.
PostgreSQL
Robusto, com recursos avançados e extensível. Suporta tipos complexos e ideal para aplicações que exigem alta integridade de dados e funcionalidades avançadas.
Oracle
Solução empresarial completa, com alto desempenho e segurança. Amplamente utilizado em grandes corporações e sistemas críticos que exigem confiabilidade.
SQL – Structured Query Language
SQL (Linguagem de Consulta Estruturada) é a linguagem padrão para interagir com bancos de dados relacionais. Foi desenvolvida nos anos 70 e se tornou um padrão ANSI/ISO.
Permite realizar operações de consulta, inserção, atualização e exclusão de dados, além de definir e modificar estruturas de banco de dados.
SELECT
SELECT nome, email FROM clientes
WHERE cidade = 'São Paulo';
INSERT
INSERT INTO produtos (nome, preco)
VALUES ('Teclado', 89.90);
UPDATE
UPDATE clientes 
SET telefone = '11999998888'
WHERE id = 42;
DELETE
DELETE FROM pedidos
WHERE data < '2023-01-01';
Esquema e Modelo de Dados
O esquema de um banco de dados define sua estrutura, incluindo tabelas, campos, tipos de dados e relacionamentos. É como a "planta" do banco, determinando como os dados serão organizados.
Criação de Tabela
CREATE TABLE clientes (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  nome TEXT NOT NULL,
  email TEXT UNIQUE,
  telefone TEXT,
  data_cadastro DATE
);
Relacionamento Entre Tabelas
CREATE TABLE pedidos (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  cliente_id INTEGER,
  data_pedido DATE,
  valor DECIMAL(10,2),
  FOREIGN KEY (cliente_id) 
  REFERENCES clientes(id)
);
Esta estrutura permite registrar clientes e seus pedidos, mantendo a integridade referencial através da chave estrangeira.
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.
Arquitetura do JDBC
Aplicação Java
Seu código Java que precisa acessar dados
Connection
Representa a conexão com o banco de dados, criada pelo DriverManager
Statement
Objeto para enviar comandos SQL para o banco de dados
ResultSet
Representa o resultado de uma consulta, permitindo navegação pelos dados
O JDBC utiliza um sistema de drivers específicos para cada banco de dados. Estes drivers são bibliotecas Java que implementam a comunicação entre a API JDBC e o protocolo específico do banco.
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.
Adicionando Bibliotecas JDBC
Download Manual
Baixe o driver JDBC adequado para seu banco
Adicione o arquivo JAR ao classpath do projeto
Referência ao JAR nas configurações do VS Code
Maven (Recomendado)
Adicione a dependência ao arquivo pom.xml:
<dependency>
  <groupId>org.xerial</groupId>
  <artifactId>sqlite-jdbc</artifactId>
  <version>3.40.1.0</version>
</dependency>
Gradle
Adicione ao build.gradle:
implementation 'org.xerial:sqlite-jdbc:3.40.1.0'
Para MySQL, substitua a dependência por:
mysql:mysql-connector-java:8.0.33
Primeiros Passos: Conectando Java ao SQLite
O SQLite é ideal para começar devido à sua simplicidade - não requer instalação de servidor, pois funciona como um arquivo local. A string de conexão indica o caminho para o arquivo do banco.
String de Conexão SQLite:
jdbc:sqlite:C:/sqlite/db/minhabase.db
Se o arquivo não existir, o SQLite o criará automaticamente quando uma conexão for estabelecida.
Preparando o Ambiente:
Crie uma pasta para armazenar o arquivo do banco de dados
Certifique-se que o caminho existe no sistema
Verifique permissões de leitura/escrita na pasta
Testes Iniciais:
Para o primeiro teste, use um caminho simples como:
jdbc:sqlite:./bancodados.db
Isso criará o banco no diretório atual do projeto
Estrutura de Código Java para Conexão SQLite
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConexaoDB {
    
    public static Connection conectar() {
        String url = "jdbc:sqlite:./loja.db";
        Connection conn = null;
        
        try {
            conn = DriverManager.getConnection(url);
            System.out.println("Conexão estabelecida!");
            return conn;
        } catch (SQLException e) {
            System.out.println(e.getMessage());
            return null;
        }
    }
}
Elementos Principais:
Connection: Interface que representa a conexão com o banco
DriverManager: Gerencia os drivers JDBC disponíveis
SQLException: Exceção para erros de banco de dados
Try-with-resources
Para uso completo, utilize o padrão try-with-resources que fecha automaticamente conexões:
try (Connection conn = conectar()) {
 // operações com o banco
} catch (SQLException e) {
 // tratamento de erro
}
Exemplo Prático: Código de Conexão
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ExemploConexao {
 
 public static Connection connect() {
 String url = "jdbc:sqlite:./aula_jdbc.db";
 Connection conn = null;
 
 try {
 conn = DriverManager.getConnection(url);
 System.out.println("Conexão com SQLite estabelecida com sucesso!");
 return conn;
 } catch (SQLException e) {
 System.out.println("Erro ao conectar ao SQLite: " + e.getMessage());
 return null;
 }
 }
 
 public static void main(String[] args) {
 Connection conn = connect();
 if (conn != null) {
 try {
 conn.close();
 System.out.println("Conexão fechada com sucesso!");
 } catch (SQLException e) {
 System.out.println("Erro ao fechar conexão: " + e.getMessage());
 }
 }
 }
}
Conectando Java ao MySQL
String de Conexão
jdbc:mysql://localhost:3306/meubanco
Parâmetros Adicionais
URL: endereço do servidor MySQL
Porta: padrão 3306
Nome do banco: deve existir previamente
Usuário e senha: obrigatórios
Código de Conexão MySQL
public static Connection conectarMySQL() {
    String url = "jdbc:mysql://localhost:3306/meubanco";
    String user = "root";
    String password = "senha";
    
    try {
        Connection conn = DriverManager.getConnection(
            url, user, password);
        System.out.println("Conectado ao MySQL!");
        return conn;
    } catch (SQLException e) {
        System.out.println("Erro: " + e.getMessage());
        return null;
    }
}
Diferente do SQLite, o MySQL exige um servidor em execução e o banco de dados deve ser criado previamente com o comando CREATE DATABASE meubanco; antes da conexão.
Configurando o Ambiente para SQLite/MySQL
Download
SQLite: arquivo JAR do driver JDBC
MySQL: instalador do servidor e driver JDBC
Ferramentas adicionais: DB Browser for SQLite
Instalação
SQLite: Adicionar JAR ao classpath
MySQL: Executar instalador e definir senha de root
Testar acesso pelo cliente padrão
Configuração
SQLite: Definir local do arquivo .db
MySQL: Criar banco e usuário específico
Verificar firewall para conexão remota
Teste
Verificar conexão pelo terminal/cliente
Testar conexão básica pelo Java
Resolver problemas de driver ou permissão
Recomendamos iniciar com SQLite pela simplicidade, e depois migrar para MySQL quando necessário mais recursos.
Comandos Básicos SQL – SELECT
Sintaxe Básica
SELECT [colunas] 
FROM [tabela]
WHERE [condição]
ORDER BY [coluna] [ASC|DESC]
LIMIT [número];
Exemplos
-- Todos os clientes
SELECT * FROM clientes;

-- Nome e email de clientes de SP
SELECT nome, email 
FROM clientes 
WHERE estado = 'SP';
Operadores em WHERE
=, >, <, >=, <=, !=: Comparações
AND, OR, NOT: Operadores lógicos
LIKE: Padrões de texto
IN: Lista de valores
BETWEEN: Intervalo de valores
Exemplo Avançado
SELECT nome, total 
FROM vendas 
WHERE data BETWEEN '2023-01-01' AND '2023-12-31' 
AND total > 1000
ORDER BY total DESC 
LIMIT 10;
INSERT – Inserção de Dados
Sintaxe
INSERT INTO tabela (coluna1, coluna2, ...) 
VALUES (valor1, valor2, ...);
Exemplo
INSERT INTO clientes (nome, email, telefone) 
VALUES ('Maria Silva', 'maria@email.com', '11999887766');
Inserindo Múltiplos Registros
INSERT INTO produtos (nome, preco, estoque) VALUES
('Teclado', 89.90, 15),
('Mouse', 45.00, 20),
('Monitor', 750.00, 5);
Statement vs PreparedStatement
Statement (Simples)
Statement stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO clientes (nome) VALUES ('João')");
Menos seguro, vulnerável a SQL Injection
PreparedStatement (Recomendado)
PreparedStatement ps = conn.prepareStatement(
    "INSERT INTO clientes (nome) VALUES (?)");
ps.setString(1, "João");
ps.executeUpdate();
Mais seguro, protege contra SQL Injection
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
DELETE – Remoção de Dados
Sintaxe
DELETE FROM tabela
WHERE condição;
Exemplos
-- Remover cliente específico
DELETE FROM clientes
WHERE id = 5;

-- Remover produtos sem estoque
DELETE FROM produtos
WHERE estoque = 0;

-- Remover pedidos antigos
DELETE FROM pedidos
WHERE data_pedido < '2022-01-01';
⚠️ ALERTA DE SEGURANÇA
Nunca execute DELETE sem WHERE! Isso apagará TODOS os registros da tabela!
O comando DELETE FROM clientes; remove todos os clientes sem possibilidade de recuperação.
Prática Segura
Use sempre WHERE com condição específica
Faça um SELECT com a mesma condição primeiro para verificar
Use LIMIT para limitar o número de registros afetados
Considere desativar registros em vez de excluí-los definitivamente
Consultas em Java usando JDBC
import java.sql.*;

public class ConsultaExemplo {
    public static void main(String[] args) {
        String url = "jdbc:sqlite:./loja.db";
        
        try (Connection conn = DriverManager.getConnection(url);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT id, nome, email FROM clientes")) {
            
            // Loop sobre os resultados
            while (rs.next()) {
                int id = rs.getInt("id");
                String nome = rs.getString("nome");
                String email = rs.getString("email");
                
                System.out.println(id + " | " + nome + " | " + email);
            }
        } catch (SQLException e) {
            System.out.println("Erro: " + e.getMessage());
        }
    }
}
O ResultSet funciona como um cursor que aponta para uma linha dos resultados. O método next() move o cursor para a próxima linha, retornando false quando não há mais linhas.
Os métodos getXXX() do ResultSet permitem obter valores de diferentes tipos (getString, getInt, getDouble, getDate, etc.).
Exemplo Prático: SELECT em Java
import java.sql.*;

public class ListarProdutos {
 public static void main(String[] args) {
 String url = "jdbc:sqlite:./loja.db";
 
 // Consulta com filtro e ordenação
 String sql = "SELECT id, nome, preco, estoque FROM produtos " +
 "WHERE preco > 50.0 ORDER BY preco DESC";
 
 try (Connection conn = DriverManager.getConnection(url);
 Statement stmt = conn.createStatement();
 ResultSet rs = stmt.executeQuery(sql)) {
 
 // Cabeçalho da tabela
 System.out.println("+---------+-------------------+----------+----------+");
 System.out.println("| ID | PRODUTO | PREÇO | ESTOQUE |");
 System.out.println("+---------+-------------------+----------+----------+");
 
 // Imprime cada produto em formato de tabela
 while (rs.next()) {
 System.out.printf("| %-7d | %-17s | R$%6.2f | %-8d |%n",
 rs.getInt("id"),
 rs.getString("nome"),
 rs.getDouble("preco"),
 rs.getInt("estoque"));
 }
 
 System.out.println("+---------+-------------------+----------+----------+");
 } catch (SQLException e) {
 System.out.println("Erro na consulta: " + e.getMessage());
 }
 }
}
Exercício Prático: CRUD Básico
Objetivo: Criar uma aplicação Java completa para gerenciar uma tabela de livros
1
Criar Tabela
CREATE TABLE livros (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  titulo TEXT NOT NULL,
  autor TEXT NOT NULL,
  ano INTEGER,
  preco REAL
);
2
Criar Classes Java
Implemente uma classe Livro e uma classe LivroDAO com métodos para:
inserir(Livro)
buscarTodos()
buscarPorId(int id)
atualizar(Livro)
excluir(int id)
3
Menu de Console
Crie um menu interativo que permita:
Listar todos os livros
Buscar livro por ID
Adicionar novo livro
Atualizar livro existente
Remover livro
4
Testes e Validação
Teste todas as operações e verifique os resultados usando um visualizador de banco de dados como o DB Browser for SQLite.
Tempo estimado: 60-90 minutos. Dica: use PreparedStatement para todas as operações que envolvem parâmetros.
Debug e Tratamento de Erros
Mensagens de Exceção SQL
SQLException: Erro geral de SQL
SQLSyntaxErrorException: Sintaxe incorreta
SQLIntegrityConstraintViolationException: Violação de restrição (chave primária, única, etc.)
SQLTimeoutException: Tempo de execução excedido
Estrutura de Tratamento
try {
    // Operações com banco
} catch (SQLException e) {
    System.err.println("Erro: " + e.getMessage());
    System.err.println("Código: " + e.getErrorCode());
    e.printStackTrace();
} finally {
    // Fechar recursos
}
Técnicas de Depuração
Logs Detalhados
Imprima SQL gerado antes de executar para verificar a sintaxe correta.
Inspeção de Estados
Verifique valores de variáveis e parâmetros antes da execução das consultas.
Transações Controladas
Use pontos de verificação com commit/rollback para testar partes específicas.
Ferramentas Externas
Use clientes de banco de dados para verificar estado das tabelas.
Boas Práticas de Integração
1
Gerencie Recursos Corretamente
Sempre feche conexões, statements e resultsets usando try-with-resources ou blocos finally.
try (Connection conn = DriverManager.getConnection(url);
     PreparedStatement ps = conn.prepareStatement(sql)) {
    // código aqui
} // recursos fechados automaticamente
2
Utilize PreparedStatement
Evite concatenação de strings em SQL. Use PreparedStatement para prevenir SQL Injection.
// ERRADO
String sql = "SELECT * FROM usuarios WHERE nome = '" + nome + "'";

// CORRETO
String sql = "SELECT * FROM usuarios WHERE nome = ?";
ps.setString(1, nome);
3
Utilize Transações
Para operações que envolvem múltiplas consultas relacionadas, use transações para garantir consistência.
conn.setAutoCommit(false);
try {
    // várias operações
    conn.commit();
} catch (Exception e) {
    conn.rollback();
}
4
Separe Lógica de Negócio do Acesso a Dados
Use o padrão DAO (Data Access Object) para encapsular o acesso ao banco de dados.
Onde Usar: Projetos e Aplicações Reais
Sistemas de Controle de Estoque
Gerenciamento de produtos, entradas, saídas, fornecedores e relatórios de vendas, essenciais para comércio e indústria.
Sistemas Acadêmicos
Cadastro de alunos, professores, notas, frequência e geração de boletins em escolas e universidades.
Aplicações Financeiras
Controle de contas, transações bancárias, investimentos e relatórios financeiros para uso pessoal ou empresarial.
E-commerce
Catálogo de produtos, gestão de pedidos, cadastro de clientes e processamento de pagamentos para lojas virtuais.
A integração Java com bancos de dados é fundamental em praticamente qualquer sistema que precise armazenar e recuperar informações de forma persistente e estruturada.
Referências e Materiais Complementares
Documentação Oficial
Tutorial JDBC Oracle - Guia completo de JDBC
Documentação SQLite - Referência oficial do SQLite
MySQL Documentation - Manual de referência do MySQL
Livros Recomendados
"Java Database Best Practices" - George Reese
"Use a Cabeça! SQL" - Lynn Beighley
"Database Design for Mere Mortals" - Michael J. Hernandez
Tutoriais Online
DevMedia: Tutorial JDBC - Em português
Baeldung: JDBC Introduction - Tutorial detalhado
SQLite Tutorial com Java - Passo a passo
Ferramentas Úteis
DBeaver - Cliente universal de banco de dados
DB Browser for SQLite - Visualizador de bancos SQLite
MySQL Workbench - Ferramenta oficial MySQL
Encerramento e Discussão
Recapitulação
Bancos de dados relacionais: tabelas, chaves, SQL
JDBC: conexão, statements, resultsets
Operações básicas: SELECT, INSERT, UPDATE, DELETE
Boas práticas: PreparedStatement, transações, fechamento de recursos
Dúvidas Frequentes
Como lidar com grandes volumes de dados?
Como implementar consultas complexas com JOIN?
Qual é o melhor banco para meu tipo de projeto?
Como migrar entre diferentes bancos de dados?
Próximos Passos
1
Implementações Avançadas
Consultas com JOIN, transações, stored procedures
2
Frameworks ORM
Hibernate, JPA para mapeamento objeto-relacional
3
Projeto Prático
Desenvolvimento de aplicação completa com banco de dados
Desafio Final
Implemente um sistema de biblioteca com tabelas para livros, autores, categorias e empréstimos, com todas as operações CRUD.