0Pricing
Java Academy · Aula

Fundamentos de JDBC

Conexões, instruções e conjuntos de resultados.

Fundamentos de JDBC é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é JDBC?

JDBC (Conectividade com Bancos de Dados Java) é a API padrão para se comunicar com bancos de dados relacionais a partir de Java.

  • Ela está no pacote java.sql.
  • Cada banco de dados fornece um controlador que implementa as interfaces JDBC.
  • Você escreve código usando interfaces como Connection, Statement e ResultSet — nunca usando diretamente as classes do fornecedor.

Essa abstração permite que o mesmo código funcione com PostgreSQL, MySQL, H2 ou Oracle.

As interfaces principais

Três interfaces realizam a maior parte do trabalho:

  • Connection — uma sessão aberta com o banco de dados.
  • Statement / PreparedStatement — envia SQL.
  • ResultSet — um cursor sobre as linhas retornadas por uma consulta.

Você obtém uma Connection de DriverManager ou de um DataSource.

Abrindo uma conexão

DriverManager.getConnection(url, user, password) retorna uma Connection ativa.

A URL do JDBC identifica o banco de dados, por exemplo, jdbc:postgresql://localhost:5432/shop. Os controladores modernos se registram automaticamente, portanto não é mais necessário chamar Class.forName(...).

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/shop";
        try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
            System.out.println("Connected: " + !conn.isClosed());
        } catch (SQLException e) {
            System.out.println("Connection failed: " + e.getMessage());
        }
    }
}

Bloco de tentativa com recursos

Connection, Statement e ResultSet implementam AutoCloseable.

Sempre abra esses recursos dentro de um bloco de tentativa com recursos para que sejam fechados automaticamente — mesmo quando uma exceção for lançada. Conexões não fechadas esgotam rapidamente o banco de dados.

  • Os recursos são fechados na ordem inversa.
  • Nenhum bloco finally é necessário.

Executando uma consulta

Para um SELECT simples, crie um Statement e chame executeQuery, que retorna um ResultSet.

O exemplo usa uma simulação em memória para que você possa ver o fluxo sem um banco de dados real. Em produção, o SQL seria executado na conexão.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Simulated result of: SELECT name FROM users
        List<String> names = List.of("Ada", "Linus", "Grace");
        System.out.println("Query returned " + names.size() + " rows:");
        for (String name : names) {
            System.out.println(" - " + name);
        }
    }
}

Lendo um ResultSet

Um ResultSet começa antes da primeira linha. Chame rs.next() em um laço; ele retorna false quando não há mais linhas.

Leia as colunas pelo nome ou por um índice que começa em 1, usando métodos tipados de leitura:

  • rs.getInt("id")
  • rs.getString("name")
  • rs.getDouble("price")
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/shop";
        try (Connection conn = DriverManager.getConnection(url, "app", "secret");
             Statement st = conn.createStatement();
             ResultSet rs = st.executeQuery("SELECT id, name FROM users")) {
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
            }
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

executeUpdate para operações de escrita

Para INSERT, UPDATE e DELETE, use executeUpdate. Ele retorna um número inteiro: a quantidade de linhas afetadas.

Use o método de execução somente quando você não souber antecipadamente se a instrução retornará um conjunto de resultados.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/shop";
        try (Connection conn = DriverManager.getConnection(url, "app", "secret");
             Statement st = conn.createStatement()) {
            int rows = st.executeUpdate("DELETE FROM sessions WHERE expired = true");
            System.out.println("Deleted " + rows + " rows");
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
}

Mapeando linhas para objetos

A maioria dos aplicativos converte cada linha em um objeto de domínio. Percorra o ResultSet e crie instâncias.

Este é o padrão, simulado para que possa ser executado de forma independente. Um record torna o mapeamento conciso.

import java.util.ArrayList;
import java.util.List;

public class Main {
    record User(int id, String name) {}

    public static void main(String[] args) {
        // Stand-in for iterating a ResultSet
        String[][] rows = {{"1", "Ada"}, {"2", "Linus"}};
        List<User> users = new ArrayList<>();
        for (String[] row : rows) {
            users.add(new User(Integer.parseInt(row[0]), row[1]));
        }
        users.forEach(System.out::println);
    }
}

Tratando SQLException

Quase todo método JDBC lança a exceção verificada SQLException.

Ela contém informações úteis para diagnóstico:

  • getMessage() — texto legível para humanos.
  • getSQLState() — o código de estado padrão com 5 caracteres.
  • getErrorCode() — o código específico do fornecedor.

Registre essas informações em vez de ignorá-las.

import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        SQLException e = new SQLException("duplicate key", "23505", 7);
        System.out.println("Message: " + e.getMessage());
        System.out.println("SQLState: " + e.getSQLState());
        System.out.println("ErrorCode: " + e.getErrorCode());
    }
}

DatabaseMetaData

conn.getMetaData() retorna um objeto DatabaseMetaData que descreve o próprio banco de dados.

Ele pode informar o nome e a versão do produto, os recursos compatíveis e até listar tabelas e colunas. É assim que ferramentas como exploradores de esquemas funcionam sem codificar diretamente os detalhes do fornecedor.

Juntando tudo

Um fluxo típico de leitura:

  • Abra uma Connection em um bloco de tentativa com recursos.
  • Crie um Statement (ou, melhor ainda, um PreparedStatement).
  • Chame executeQuery e percorra os resultados com rs.next().
  • Mapeie as colunas para objetos.
  • Deixe o bloco de tentativa com recursos fechar tudo.

Na próxima lição, tornaremos as consultas seguras contra injeção.

Verificação rápida

O que Statement.executeUpdate retorna?

Recapitulação

Agora você conhece o fluxo principal do JDBC:

  • DriverManager.getConnection abre uma Connection.
  • Statement envia SQL; executeQuery retorna um ResultSet, e executeUpdate retorna a quantidade de linhas afetadas.
  • Percorra os resultados com rs.next() e use métodos tipados de leitura.
  • Sempre use blocos de tentativa com recursos e trate SQLException usando seus códigos de estado e de erro.

Perguntas Frequentes

A aula “Fundamentos de JDBC” é grátis?

Sim — o texto completo de “Fundamentos de JDBC” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Fundamentos de JDBC”?

Conexões, instruções e conjuntos de resultados. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Fundamentos de JDBC”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Fundamentos de JDBC
  2. PreparedStatement
  3. Transações
  4. Pool de conexões com HikariCP
← Voltar para Java Academy