50 Preguntas Esenciales de Entrevista JDBC y Respuestas Expertas (2026)

Preparar una entrevista JDBC exige un dominio profundo de conectividad de bases de datos, ajuste de rendimiento y mejores prácticas de seguridad. Las siguientes 50 preguntas cubren conceptos centrales y escenarios reales que los reclutadores priorizan.

👉 Descarga Gratuita PDF: Preguntas y Respuestas de Entrevista JDBC

1) ¿Qué es JDBC y por qué es importante en aplicaciones Java?

JDBC (Java Database Connectivity) es la API central que permite a programas Java interactuar con bases de datos relacionales. Estandariza ejecución SQL, manejo de resultados y control de transacciones, permitiendo a desarrolladores escribir código database-agnostic que puede cambiar entre MySQL, Oracle, PostgreSQL y otros con cambios mínimos.

2) ¿Cuáles son los cuatro tipos de drivers JDBC y sus diferencias clave?

• Tipo 1 (JDBC-ODBC Bridge): Conecta JDBC a ODBC; fácil uso pero requiere ODBC y es lento.
• Tipo 2 (Native API): Llama librerías nativas BD; más rápido que Tipo 1 pero dependiente de plataforma.
• Tipo 3 (Network Protocol): Usa middleware para traducir llamadas; database-agnostic pero añade overhead red.
• Tipo 4 (Thin Driver): Java puro, comunica directamente con BD; mayor rendimiento y portabilidad. La mayoría apps modernas usan Tipo 4.

3) Esboce el ciclo de vida de un programa JDBC.

1. Cargar driver: Class.forName("com.mysql.cj.jdbc.Driver")
2. Establecer Connection vía DriverManager o DataSource.
3. Crear Statement, PreparedStatement o CallableStatement.
4. Ejecutar SQL (consulta, actualización o procedimiento).
5. Procesar ResultSet si aplica.
6. Cerrar todos recursos (preferir try-with-resources).

4) ¿Cuándo usar Statement, PreparedStatement o CallableStatement?

• Statement: SQL estático; rápido para consultas puntuales.
• PreparedStatement: Consultas parametrizadas; protege contra inyección SQL y mejora rendimiento precompilando.
• CallableStatement: Procedimientos almacenados o funciones; encapsula lógica BD compleja.

5) ¿Cómo gestiona transacciones en JDBC?

1. Desactivar auto-commit: conn.setAutoCommit(false)
2. Ejecutar múltiples sentencias.
3. En éxito, conn.commit(); en fallo, conn.rollback().

Usar este patrón para operaciones atómicas como transferencias de fondos.

6) ¿Cuáles son pros y contras de connection pooling JDBC?

• Pros: Reutiliza conexiones, reduce latencia, escala bajo carga.
• Contras: Requiere configuración cuidadosa; conexiones stale pueden ocurrir si no se refrescan.

Frameworks como HikariCP y Apache DBCP son estándares industriales.

7) Distinga execute(), executeQuery() y executeUpdate().

• execute(): Cualquier SQL; devuelve boolean indicando si se produce ResultSet.
• executeQuery(): Sentencias SELECT; devuelve ResultSet.
• executeUpdate(): INSERT, UPDATE, DELETE; devuelve cuenta filas afectadas.

8) ¿Qué estrategias mejoran rendimiento JDBC?

• Usar PreparedStatement para precompilación.
• Batch updates vía addBatch()/executeBatch().
• Connection pooling.
• Seleccionar solo columnas necesarias.
• Cerrar recursos promptamente.

9) Explique batch updates en JDBC.

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

Reduce round-trips y aumenta throughput.

10) ¿Qué papel juega ResultSet?

ResultSet mantiene resultados de consultas. Puede ser forward-only, scrollable o updatable según flags de creación.

11) Compare JDBC y ODBC.

• JDBC: Java puro, independiente plataforma, alto rendimiento.
• ODBC: Basado en C, dependiente plataforma, requiere drivers nativos.

12) Identifique componentes arquitectura JDBC.

1. JDBC API (Connection, Statement, ResultSet).
2. Driver Manager (registra drivers).
3. Implementaciones drivers (Tipos 1-4).
4. Backend base de datos.

13) Explique ResultSetMetaData vs DatabaseMetaData.

• ResultSetMetaData: Nombres columnas, tipos de consulta específica.
• DatabaseMetaData: Nombre driver, producto BD, características SQL soportadas.

14) ¿Cómo usar Savepoints?

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

15) Defina RowSet y sus variantes.

• JdbcRowSet – conectado.
• CachedRowSet – desconectado, serializable.
• WebRowSet – basado en XML.
• FilteredRowSet – vista con filtros.
• JoinRowSet – fusiona múltiples RowSets.

16) ¿Cómo maneja JDBC excepciones SQL?

SQLException proporciona getErrorCode(), getSQLState() y getMessage(). Siempre loggear y rollback en fallo.

17) ¿Qué es batch processing?

Agrupar múltiples sentencias DML en un solo round-trip; usar addBatch() y executeBatch().

18) Liste tipos de statement de nuevo.

• Statement – SQL estático.
• PreparedStatement – parametrizado.
• CallableStatement – procedimientos almacenados.

19) Gestión eficiente de conexiones.

Preferir DataSource con connection pooling. Usar try-with-resources para limpieza automática.

20) JDBC Statement vs Hibernate Session.

• JDBC: Bajo nivel, mapeo manual.
• Hibernate: ORM, caché, generación SQL automática.

21) Recuperar claves auto-generadas.

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

22) Manejo BLOB y CLOB.

• BLOB – streams binarios.
• CLOB – streams caracteres.

23) Hacer 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", "NombreActualizado"); rs.updateRow();

24) DataSource vs DriverManager.

• DriverManager – simple, sin pooling.
• DataSource – lookup JNDI, pooling, soporte XA.

25) Batch processing con PreparedStatement.

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

26) Usando DatabaseMetaData.

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

27) Recap de variantes execute.

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

28) Cerrar recursos JDBC.

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

29) Optimizaciones rendimiento comunes.

• Connection pooling.
• PreparedStatement sobre Statement.
• Batch updates.
• Ajuste fetch size.
• Recuperación selectiva columnas.

30) Llamar procedimientos almacenados.

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

31) Internos de connection pooling JDBC.

Al inicio, pool crea conjunto fijo conexiones. Peticiones toman prestada conexión; la devuelven tras uso, manteniendo recursos en memoria.

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 – directo, sin pooling.
• DataSource – pooled, XA, JNDI.

34) Causas comunes "No suitable driver found".

• Driver JAR faltante en classpath.
• URL JDBC incorrecta.
• Falta Class.forName() (pre-Java 9).
• Mismatch versión driver-BD.

35) Prevenir inyección SQL.

• Siempre usar PreparedStatement con parámetros.
• Validar y sanitizar entrada usuario.
• Limitar privilegios BD.

36) JDBC vs ORM (Hibernate).

• JDBC: control fino, mapeo manual, ligero.
• Hibernate: ORM automático, caché, curva aprendizaje mayor.

37) Logging consultas SQL.

• Habilitar logging driver (ej. MySQL logger=com.mysql.cj.log.StandardLogger).
  
• Usar P6Spy o datasource-proxy para interceptar y loggear.

38) Multihilo seguro con JDBC.

• No compartir objetos Connection entre hilos.
• Tomar prestada conexión del pool por hilo.
• Cerrar recursos con try-with-resources.

39) JDBC en Spring / Spring Boot.

Spring's JdbcTemplate maneja boilerplate, traducción excepciones y connection pooling automáticamente.

40) Estados conexión JDBC.

• Inicializado → Abierto → En Transacción → Commitido/Rollback → Cerrado.

41) Recap tipos drivers.

• Tipo 1 – bajo rendimiento, requiere ODBC.
• Tipo 2 – nativo, rendimiento medio.
• Tipo 3 – middleware, rendimiento moderado.
• Tipo 4 – Java puro, mayor rendimiento.

42) Niveles aislamiento transacción.

• READ_UNCOMMITTED – dirty reads.
• READ_COMMITTED – por defecto, previene dirty reads.
• REPEATABLE_READ – previene non-repeatable reads.
• SERIALIZABLE – aislamiento estricto, evita phantom reads.

43) Transacciones distribuidas (XA).

• Usar javax.sql.XADataSource y gestor JTA (Atomikos, Bitronix, Spring).
• Two-phase commit coordina commits across múltiples BDs.

44) Perfilado rendimiento JDBC.

• P6Spy, datasource-proxy para logging consultas.
• Java Flight Recorder / JVisualVM para uso conexiones.
• Planes EXPLAIN BD para tuning consultas.
• Prometheus + Grafana para métricas.

45) Prevenir fugas memoria JDBC.

• Siempre cerrar ResultSet, Statement, Connection vía try-with-resources.
• Configurar timeouts pool (maxIdleTime, maxLifetime).
• Evitar mantener ResultSets fuera de scope.

46) JDBC para microservicios/nube.

• HikariCP para pooling ligero.
• Sesiones JDBC stateless.
• Read replicas, caching (Redis).
• Circuit breakers Resilience4j para failover BD.

47) Manejo graceful fallos conexión.

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

48) Diferencias commit, rollback y savepoint.

• Commit – finaliza todos cambios.
• Rollback – revierte a último commit.
• Savepoint – objetivo rollback parcial.

49) Utilidad metadatos JDBC.

• Introspección esquema dinámica.
• Comprobaciones capacidades BD.
• Tooling para generación ORM.

50) Mejores prácticas JDBC empresarial.

1. Usar DataSource con pooling.
2. Preferir PreparedStatement.
3. Manejar transacciones con aislamiento adecuado.
4. Operaciones batch y paginación.
5. Loggear y monitorizar consultas.
6. Manejar graceful excepciones y reintentos.

🔍 Top Preguntas Entrevista JDBC con Escenarios Reales y Respuestas Estratégicas

A continuación, 10 preguntas cuidadosamente elaboradas de entrevista JDBC, con lo que esperan entrevistadores y fuertes respuestas de ejemplo.

1) ¿Qué es JDBC y por qué es importante?

Respuesta esperada: JDBC es la API Java para acceso BD; abstrae ejecución SQL, manejo resultados y transacciones, permitiendo código database-agnostic.

2) Explique tipos drivers JDBC.

Respuesta esperada: Cuatro tipos: JDBC-ODBC Bridge, Native API, Network Protocol, Thin Driver. Tipo 4 es el más común hoy.

3) ¿Cómo gestiona conexiones eficientemente?

Respuesta esperada: Usar connection pools como HikariCP; evitar abrir/cerrar conexiones por petición.

4) Distinga Statement, PreparedStatement y CallableStatement.

Respuesta esperada: Statement – SQL estático; PreparedStatement – parametrizado, previene inyección; CallableStatement – procedimientos almacenados.

5) Describa una optimización rendimiento JDBC que realizó.

Respuesta esperada: Reemplacé concatenación strings con PreparedStatement, introduje pooling y usé batch inserts; reduje tiempo respuesta 40%.

6) ¿Cómo previene inyección SQL?

Respuesta esperada: Usar PreparedStatement; validar entrada; limitar privilegios BD.

7) Solucione fallo conexión JDBC.

Respuesta esperada: Verificar URL, credenciales, red, driver jar; revisar logs; corregir puerto mal configurado.

8) Gestione transacciones en JDBC.

Respuesta esperada: Desactivar auto-commit, realizar operaciones, commit o rollback según resultado; asegura cumplimiento ACID.

9) Resuelva problema BD desafiante con JDBC.

Respuesta esperada: Implementé batch processing para inserts masivos, reduciendo tiempo de minutos a segundos.

10) Priorice mejoras JDBC bajo plazos ajustados.

Respuesta esperada: Evaluar impacto, comunicar claramente, abordar items alto impacto primero, colaborar para cumplir SLA.