50 Perguntas Essenciais de Entrevista JDBC & Respostas de Especialistas (2026)

Preparar-se para uma entrevista JDBC exige compreensão profunda de conectividade com banco de dados, performance tuning e security best practices. As seguintes 50 perguntas cobrem conceitos core e cenários real-world que recrutadores priorizam.

👉 Download Gratuito PDF: Perguntas e Respostas de Entrevista JDBC

1) O que é JDBC e por que é importante em aplicações Java?

JDBC (Java Database Connectivity) é a API core que permite programas Java interagirem com bancos de dados relacionais. Padroniza execução SQL, handling de resultados e controle de transação, permitindo developers escreverem código database-agnostic que pode trocar entre MySQL, Oracle, PostgreSQL e outros com mudanças mínimas.

2) Quais são os quatro tipos de driver JDBC e suas diferenças chave?

• Tipo 1 (JDBC-ODBC Bridge): Faz bridge JDBC para ODBC; fácil de usar mas requer ODBC e é lento.
• Tipo 2 (Native API): Chama libraries nativas do DB; mais rápido que Tipo 1 mas platform-dependent.
• Tipo 3 (Network Protocol): Usa middleware para traduzir chamadas; database-agnostic mas adiciona overhead de rede.
• Tipo 4 (Thin Driver): Pure Java, comunica diretamente com DB; maior performance e portabilidade. Apps modernas usam Tipo 4.

3) Descreva o ciclo de vida de um programa JDBC.

1. Carregar driver: Class.forName("com.mysql.cj.jdbc.Driver")
2. Estabelecer Connection via DriverManager ou DataSource.
3. Criar Statement, PreparedStatement ou CallableStatement.
4. Executar SQL (query, update ou procedure).
5. Processar ResultSet se aplicável.
6. Fechar todos recursos (preferir try-with-resources).

4) Quando usar Statement, PreparedStatement ou CallableStatement?

• Statement: SQL estático; rápido para queries one-off.
• PreparedStatement: Queries parametrizadas; protege contra SQL injection e melhora performance pré-compilando.
• CallableStatement: Stored procedures ou functions; encapsula lógica complexa de DB.

5) Como gerenciar transações no JDBC?

1. Desabilitar auto-commit: conn.setAutoCommit(false)
2. Executar múltiplos statements.
3. Sucesso: conn.commit(); falha: conn.rollback().

Use este padrão para operações atômicas como transferências de fundos.

6) Quais são os prós e contras de connection pooling JDBC?

• Prós: Reusa conexões, reduz latência, escala sob carga.
• Contras: Requer configuração cuidadosa; conexões stale podem ocorrer se não refrescadas.

Frameworks como HikariCP e Apache DBCP são padrões da indústria.

7) Distinguir execute(), executeQuery() e executeUpdate().

• execute(): Qualquer SQL; retorna boolean indicando se ResultSet produzido.
• executeQuery(): Statements SELECT; retorna ResultSet.
• executeUpdate(): INSERT, UPDATE, DELETE; retorna contagem de linhas afetadas.

8) Quais estratégias melhoram performance JDBC?

• Usar PreparedStatement para pré-compilação.
• Batch updates via addBatch()/executeBatch().
• Connection pooling.
• Selecionar apenas colunas necessárias.
• Fechar recursos prontamente.

9) Explique batch updates no JDBC.

PreparedStatement ps = conn.prepareStatement("INSERT INTO student VALUES(?,?)"); for(int i=1;i<=1000;i++){ ps.setInt(1,i); ps.setString(2,"Name"+i); ps.addBatch(); } ps.executeBatch();

Reduz round-trips e aumenta throughput.

10) Qual papel do ResultSet?

ResultSet mantém resultados de query. Pode ser forward-only, scrollable ou updatable dependendo de flags de criação.

11) Comparar JDBC e ODBC.

• JDBC: Pure Java, platform-independent, alta performance.
• ODBC: C-based, platform-dependent, requer drivers nativos.

12) Identifique componentes da arquitetura JDBC.

1. JDBC API (Connection, Statement, ResultSet).
2. Driver Manager (registra drivers).
3. Implementações de Driver (Tipos 1-4).
4. Backend de banco de dados.

13) Explique ResultSetMetaData vs DatabaseMetaData.

• ResultSetMetaData: Nomes de colunas, tipos de query específica.
• DatabaseMetaData: Nome do driver, produto do banco, features SQL suportadas.

14) Como usar Savepoints?

conn.setAutoCommit(false); Savepoint sp = conn.setSavepoint("sp1"); // operations conn.rollback(sp); // partial rollback conn.commit();

15) Defina RowSet e suas variantes.

• JdbcRowSet – connected.
• CachedRowSet – disconnected, serializable.
• WebRowSet – XML-based.
• FilteredRowSet – view com filtros.
• JoinRowSet – merge de múltiplos RowSets.

16) Como JDBC lida com SQL exceptions?

SQLException fornece getErrorCode(), getSQLState() e getMessage(). Sempre log e rollback em falha.

17) O que é batch processing?

Agrupa múltiplos statements DML em single round-trip; usa addBatch() e executeBatch().

18) Liste tipos de statement novamente.

• Statement – SQL estático.
• PreparedStatement – parametrizado.
• CallableStatement – stored procedures.

19) Gerenciamento eficiente de conexão.

Preferir DataSource com connection pooling. Usar try-with-resources para cleanup automático.

20) JDBC Statement vs Hibernate Session.

• JDBC: Low-level, manual mapping.
• Hibernate: ORM, caching, geração automática de SQL.

21) Recuperar chaves auto-geradas.

PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); ps.executeUpdate(); ResultSet rs = ps.getGeneratedKeys();

22) Handling de BLOB e CLOB.

• BLOB – binary streams.
• CLOB – character streams.

23) Tornando ResultSet scrollable/updatable.

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = stmt.executeQuery("SELECT * FROM EMPLOYEE"); rs.absolute(3); rs.updateString("name", "UpdatedName"); rs.updateRow();

24) DataSource vs DriverManager.

• DriverManager – simples, sem pooling.
• DataSource – JNDI lookup, pooling, XA support.

25) Batch processing com PreparedStatement.

for(int i=1;i<=5;i++){ ps.setInt(1,i); ps.setString(2,"Student"+i); ps.addBatch(); } ps.executeBatch();

26) Usando DatabaseMetaData.

DatabaseMetaData dbmd = conn.getMetaData(); System.out.println("DB: " + dbmd.getDatabaseProductName());

27) Recap de variants do execute.

• execute() – boolean.
• executeQuery() – ResultSet.
• executeUpdate() – int.

28) Fechando recursos JDBC.

try (Connection c = ds.getConnection(); Statement s = c.createStatement(); ResultSet rs = s.executeQuery("SELECT * FROM EMPLOYEE")) { while(rs.next()){ /* process */ } }

29) Otimizações de performance comuns.

• Connection pooling.
• PreparedStatement sobre Statement.
• Batch updates.
• Fetch size tuning.
• Retrieval seletivo de colunas.

30) Chamando stored procedures.

CallableStatement cs = conn.prepareCall("{call getEmployeeSalary(?)}"); cs.setInt(1,101); ResultSet rs = cs.executeQuery();

31) Internals de connection pooling JDBC.

Na init, pool cria conjunto fixo de conexões. Requests pegam emprestado uma conexão; devolvem após uso, mantendo recursos em memória.

32) Configurar HikariCP.

HikariConfig cfg = new HikariConfig(); cfg.setJdbcUrl("jdbc:mysql://localhost:3306/testdb"); cfg.setUsername("root"); cfg.setPassword("pw"); cfg.setMaximumPoolSize(10); HikariDataSource ds = new HikariDataSource(cfg);

33) DriverManager vs DataSource.

• DriverManager – direto, sem pooling.
• DataSource – pooled, XA, JNDI.

34) Causas comuns de "No suitable driver found".

• Driver JAR faltando no classpath.
• JDBC URL incorreta.
• Faltando Class.forName() (pre-Java 9).
• Mismatch versão driver-DB.

35) Prevenir SQL injection.

• Sempre usar PreparedStatement com parâmetros.
• Validar e sanitizar input do usuário.
• Limitar privilégios do DB.

36) JDBC vs ORM (Hibernate).

• JDBC: controle fino, manual mapping, leve.
• Hibernate: ORM automático, caching, curva de aprendizado maior.

37) Logging de SQL queries.

• Habilitar driver logging (ex.: MySQL's logger=com.mysql.cj.log.StandardLogger).
  
• Usar P6Spy ou datasource-proxy para interceptar e logar.

38) Multithreading seguro com JDBC.

• Não compartilhar objetos Connection across threads.
• Pegar conexão do pool por thread.
• Fechar recursos com try-with-resources.

39) JDBC no Spring / Spring Boot.

Spring's JdbcTemplate lida com boilerplate, exception translation e connection pooling automaticamente.

40) Estados de conexão JDBC.

• Initialized → Open → In Transaction → Committed/Rolled-back → Closed.

41) Recap dos tipos de driver.

• Tipo 1 – baixa performance, requer ODBC.
• Tipo 2 – nativo, performance média.
• Tipo 3 – middleware, performance moderada.
• Tipo 4 – pure Java, maior performance.

42) Níveis de isolamento de transação.

• READ_UNCOMMITTED – dirty reads.
• READ_COMMITTED – padrão, previne dirty reads.
• REPEATABLE_READ – previne non-repeatable reads.
• SERIALIZABLE – isolamento estrito, evita phantom reads.

43) Transações distribuídas (XA).

• Usar javax.sql.XADataSource e JTA manager (Atomikos, Bitronix, Spring).
• Two-phase commit coordena commits across múltiplos DBs.

44) Profiling de performance JDBC.

• P6Spy, datasource-proxy para query logging.
• Java Flight Recorder / JVisualVM para connection usage.
• Database EXPLAIN plans para query tuning.
• Prometheus + Grafana para métricas.

45) Prevenindo memory leaks JDBC.

• Sempre fechar ResultSet, Statement, Connection via try-with-resources.
• Configurar pool timeouts (maxIdleTime, maxLifetime).
• Evitar segurar ResultSets além do escopo.

46) JDBC para microservices/cloud.

• HikariCP para pooling leve.
• Sessões JDBC stateless.
• Read replicas, caching (Redis).
• Resilience4j circuit breakers para DB failover.

47) Handling gracioso de falhas de conexão.

for(int i=0;i<3;i++){ try(Connection c=ds.getConnection()){ break; } catch(SQLTransientConnectionException e){ Thread.sleep(1000*(i+1)); } }

48) Diferenças entre commit, rollback e savepoint.

• Commit – finaliza todas mudanças.
• Rollback – reverte para último commit.
• Savepoint – target de rollback parcial.

49) Utilidade de metadata JDBC.

• Introspecção dinâmica de schema.
• Checks de capacidade do banco.
• Tooling para geração de ORM.

50) Best practices para JDBC enterprise.

1. Usar DataSource com pooling.
2. Preferir PreparedStatement.
3. Tratar transações com isolamento adequado.
4. Batch operations e paginação.
5. Log e monitorar queries.
6. Tratar graciosamente exceções e retries.

🔍 Top JDBC Interview Questions com Cenários Real-World & Respostas Estratégicas

Abaixo estão 10 perguntas cuidadosamente elaboradas de entrevista JDBC, com o que entrevistadores esperam e fortes respostas de exemplo.

1) O que é JDBC e por que é importante?

Resposta esperada: JDBC é a API Java para acesso a banco de dados; abstrai execução SQL, handling de resultados e transações, permitindo código database-agnostic.

2) Explique tipos de driver JDBC.

Resposta esperada: Quatro tipos: JDBC-ODBC Bridge, Native API, Network Protocol, Thin Driver. Tipo 4 é mais comum hoje.

3) Como gerenciar conexões eficientemente?

Resposta esperada: Usar connection pools como HikariCP; evitar abrir/fechar conexões por request.

4) Distinguir Statement, PreparedStatement e CallableStatement.

Resposta esperada: Statement – SQL estático; PreparedStatement – parametrizado, previne injection; CallableStatement – stored procedures.

5) Descreva otimização de performance JDBC que realizou.

Resposta esperada: Substituiu string concatenation por PreparedStatement, introduziu pooling e usou batch inserts; reduziu response time em 40%.

6) Como prevenir SQL injection?

Resposta esperada: Usar PreparedStatement; validar input; limitar privilégios DB.

7) Troubleshoot de falha de conexão JDBC.

Resposta esperada: Verificar URL, credenciais, rede, driver jar; revisar logs; corrigir porta mal configurada.

8) Gerenciar transações no JDBC.

Resposta esperada: Desabilitar auto-commit, realizar operações, commit ou rollback baseado em outcome; garante compliance ACID.

9) Resolver issue desafiador de DB com JDBC.

Resposta esperada: Implementou batch processing para bulk inserts, cortando tempo de minutos para segundos.

10) Priorizar enhancements JDBC sob deadlines apertados.

Resposta esperada: Avaliar impacto, comunicar claramente, atacar itens high-impact primeiro, colaborar para meet SLA.