50 Essentiële JDBC Interviewvragen & Expert Antwoorden (2026)

Zich voorbereiden op een JDBC-gesprek vereist een diep begrip van databaseconnectiviteit, prestatie-tuning en security best practices. De volgende 50 vragen dekken kernconcepten en real-world scenario's die recruiters prioritair vinden.

👉 Gratis PDF-download: JDBC Interviewvragen & Antwoorden

1) Wat is JDBC en waarom is het belangrijk in Java-applicaties?

JDBC (Java Database Connectivity) is de kern-API waarmee Java-programma's communiceren met relationele databases. Het standaardiseert SQL-uitvoering, resultaatverwerking en transactiebeheer, waardoor ontwikkelaars database-agnostische code kunnen schrijven die met minimale wijzigingen kan schakelen tussen MySQL, Oracle, PostgreSQL en anderen.

2) Wat zijn de vier JDBC-drivertypen en hun belangrijkste verschillen?

• Type 1 (JDBC-ODBC Bridge): Brugt JDBC naar ODBC; makkelijk te gebruiken maar vereist ODBC en is traag.
• Type 2 (Native API): Roept native DB-bibliotheken aan; sneller dan Type 1 maar platform-afhankelijk.
• Type 3 (Network Protocol): Gebruikt middleware om oproepen te vertalen; database-agnostisch maar voegt netwerk-overhead toe.
• Type 4 (Thin Driver): Pure Java, communiceert direct met DB; hoogste prestaties en portabiliteit. Meest moderne apps gebruiken Type 4.

3) Schets de levenscyclus van een JDBC-programma.

1. Laad de driver: Class.forName("com.mysql.cj.jdbc.Driver")
2. Vestig een Connection via DriverManager of een DataSource.
3. Maak een Statement, PreparedStatement, of CallableStatement.
4. Voer de SQL uit (query, update of procedure).
5. Verwerk de ResultSet indien van toepassing.
6. Sluit alle resources (prefereer try-with-resources).

4) Wanneer moet u Statement, PreparedStatement of CallableStatement gebruiken?

• Statement: Statische SQL; snel voor eenmalige queries.
• PreparedStatement: Geparametriseerde queries; beschermt tegen SQL-injectie en verbetert prestaties door precompilatie.
• CallableStatement: Opgeslagen procedures of functies; inkapselt complexe DB-logica.

5) Hoe beheert u transacties in JDBC?

1. Schakel auto-commit uit: conn.setAutoCommit(false)
2. Voer meerdere statements uit.
3. Bij succes conn.commit(); bij falen conn.rollback().

Gebruik dit patroon voor atomische operaties zoals geldoverdrachten.

6) Wat zijn de voor- en nadelen van JDBC-connection pooling?

• Voordelen: Hergebruikt verbindingen, vermindert latentie, schaalt onder belasting.
• Nadelen: Vereist zorgvuldige configuratie; verouderde verbindingen kunnen optreden als niet verversd.

Frameworks zoals HikariCP en Apache DBCP zijn industriestandaarden.

7) Onderscheid execute(), executeQuery() en executeUpdate().

• execute(): Elke SQL; retourneert boolean of een ResultSet geproduceerd wordt.
• executeQuery(): SELECT-statements; retourneert een ResultSet.
• executeUpdate(): INSERT, UPDATE, DELETE; retourneert aantal beïnvloede rijen.

8) Welke strategieën verbeteren JDBC-prestaties?

• Gebruik PreparedStatement voor precompilatie.
• Batch-updates via addBatch()/executeBatch().
• Connection pooling.
• Selecteer alleen benodigde kolommen.
• Sluit resources prompt.

9) Leg batch-updates in JDBC uit.

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

Vermindert round-trips en verhoopt doorvoer.

10) Welke rol speelt ResultSet?

ResultSet bevat queryresultaten. Het kan forward-only, scrollable of updatable zijn afhankelijk van creatievlaggen.

11) Vergelijk JDBC en ODBC.

• JDBC: Pure Java, platform-onafhankelijk, hoge prestaties.
• ODBC: C-gebaseerd, platform-afhankelijk, vereist native drivers.

12) Identificeer JDBC-architectuurcomponenten.

1. JDBC API (Connection, Statement, ResultSet).
2. Driver Manager (registreert drivers).
3. Driver-implementaties (Type 1-4).
4. Database-backend.

13) Leg ResultSetMetaData vs DatabaseMetaData uit.

• ResultSetMetaData: Kolomnamen, typen van een specifieke query.
• DatabaseMetaData: Drivernaam, databaseproduct, ondersteunde SQL-functies.

14) Hoe Savepoints te gebruiken?

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

15) Definieer RowSet en zijn varianten.

• JdbcRowSet – verbonden.
• CachedRowSet – losgekoppeld, serialiseerbaar.
• WebRowSet – XML-gebaseerd.
• FilteredRowSet – weergave met filters.
• JoinRowSet – voegt meerdere RowSets samen.

16) Hoe JDBC SQL-exceptions afhandelt.

SQLException biedt getErrorCode(), getSQLState() en getMessage(). Altijd loggen en rollback bij falen.

17) Wat is batchverwerking?

Groeperen van meerdere DML-statements in een enkele round-trip; gebruik addBatch() en executeBatch().

18) Statement-typen overzicht.

• Statement – statische SQL.
• PreparedStatement – geparametriseerd.
• CallableStatement – opgeslagen procedures.

19) Efficiënt connection management.

Prefereer DataSource met connection pooling. Gebruik try-with-resources voor automatische cleanup.

20) JDBC Statement vs Hibernate Session.

• JDBC: Laag-niveau, handmatige mapping.
• Hibernate: ORM, caching, automatische SQL-generatie.

21) Auto-gegenereerde keys ophalen.

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

22) BLOB en CLOB afhandeling.

• BLOB – binaire streams.
• CLOB – karakterstreams.

23) ResultSet scrollable/updatable maken.

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 – simpel, geen pooling.
• DataSource – JNDI-lookup, pooling, XA-ondersteuning.

25) Batchverwerking met PreparedStatement.

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

26) DatabaseMetaData gebruiken.

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

27) Recap execute-varianten.

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

28) JDBC-resources sluiten.

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

29) Veelvoorkomende prestatie-optimalisaties.

• Connection pooling.
• PreparedStatement boven Statement.
• Batch-updates.
• Fetch-size tuning.
• Selectieve kolom-ophaling.

30) Opgeslagen procedures aanroepen.

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

31) JDBC-connection pooling internals.

Bij initialisatie creëert een pool een vast aantal verbindingen. Verzoeken lenen een verbinding; geven het terug na gebruik, houdend resources in geheugen.

32) HikariCP configureren.

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

34) Veelvoorkomende "No suitable driver found" oorzaken.

• Driver JAR ontbreekt in classpath.
• Onjuiste JDBC-URL.
• Ontbrekende Class.forName() (pre-Java 9).
• Driver-DB versie-mismatch.

35) SQL-injectie voorkomen.

• Altijd PreparedStatement met parameters gebruiken.
• Gebruikersinput valideren en sanitiseren.
• DB-privileges beperken.

36) JDBC vs ORM (Hibernate).

• JDBC: fijn controle, handmatige mapping, lichtgewicht.
• Hibernate: automatische ORM, caching, hogere leercurve.

37) SQL-queries loggen.

• Driver-logging inschakelen (bijv. MySQL's logger=com.mysql.cj.log.StandardLogger).
• P6Spy of datasource-proxy gebruiken om te intercepten en loggen.

38) Veilige multithreading met JDBC.

• Deel geen Connection-objecten over threads.
• Len een verbinding uit een pool per thread.
• Sluit resources met try-with-resources.

39) JDBC in Spring / Spring Boot.

Spring's JdbcTemplate hanteert boilerplate, exception-vertaling en connection pooling automatisch.

40) JDBC Connection-statussen.

• Geïnitialiseerd → Open → In Transactie → Gecommit/Rolled-back → Gesloten.

41) Recap driver-typen.

• Type 1 – lage prestaties, vereist ODBC.
• Type 2 – native, medium prestaties.
• Type 3 – middleware, matige prestaties.
• Type 4 – pure Java, hoogste prestaties.

42) Transactie-isolatieniveaus.

• READ_UNCOMMITTED – dirty reads.
• READ_COMMITTED – standaard, voorkomt dirty reads.
• REPEATABLE_READ – voorkomt non-repeatable reads.
• SERIALIZABLE – strikte isolatie, voorkomt phantom reads.

43) Gedistribueerde (XA) transacties.

• Gebruik javax.sql.XADataSource en een JTA-manager (Atomikos, Bitronix, Spring).
• Two-phase commit coördineert commits over meerdere DB's.

44) JDBC-prestaties profileren.

• P6Spy, datasource-proxy voor query-logging.
• Java Flight Recorder / JVisualVM voor connection-gebruik.
• Database EXPLAIN-plannen voor query-tuning.
• Prometheus + Grafana voor metrics.

45) JDBC-geheugenlekken voorkomen.

• Altijd ResultSet, Statement, Connection sluiten via try-with-resources.
• Pool-timeouts configureren (maxIdleTime, maxLifetime).
• Vermijd ResultSets buiten scope vasthouden.

46) JDBC voor microservices/cloud.

• HikariCP voor lichtgewicht pooling.
• Stateless JDBC-sessies.
• Read replicas, caching (Redis).
• Resilience4j circuit breakers voor DB-failover.

47) Netjes verbindingsfouten afhandelen.

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

48) Commit, rollback en savepoint verschillen.

• Commit – finaliseert alle wijzigingen.
• Rollback – herstelt naar laatste commit.
• Savepoint – gedeeltelijke rollback-target.

49) JDBC-metadata bruikbaarheid.

• Dynamische schema-introspectie.
• Database-capability-checks.
• Tooling voor ORM-generatie.

50) Best practices voor enterprise JDBC.

1. Gebruik DataSource met pooling.
2. Prefereer PreparedStatement.
3. Behandel transacties met juiste isolatie.
4. Batch-operaties en paginering.
5. Log en monitor queries.
6. Netjes exceptions en retries afhandelen.

🔍 Top JDBC Interviewvragen met Real-World Scenario's & Strategische Antwoorden

Hieronder 10 zorgvuldig opgestelde JDBC-interviewvragen, met wat interviewers verwachten en sterke voorbeeldantwoorden.

1) Wat is JDBC en waarom is het belangrijk?

Verwacht antwoord: JDBC is de Java-API voor database-toegang; het abstraheert SQL-uitvoering, resultaatverwerking en transacties, wat database-agnostische code mogelijk maakt.

2) Leg JDBC-drivertypen uit.

Verwacht antwoord: Vier typen: JDBC-ODBC Bridge, Native API, Network Protocol, Thin Driver. Type 4 is vandaag de dag meest gebruikelijk.

3) Hoe beheert u verbindingen efficiënt?

Verwacht antwoord: Gebruik connection pools zoals HikariCP; vermijd openen/sluiten van verbindingen per verzoek.

4) Onderscheid Statement, PreparedStatement en CallableStatement.

Verwacht antwoord: Statement – statische SQL; PreparedStatement – geparametriseerd, voorkomt injectie; CallableStatement – opgeslagen procedures.

5) Beschrijf een JDBC-prestatie-optimalisatie die u uitvoerde.

Verwacht antwoord: Vervang string-concatenatie door PreparedStatement, introduceerde pooling en gebruikte batch-inserts; responstijd verminderd met 40%.

6) Hoe voorkomt u SQL-injectie?

Verwacht antwoord: Gebruik PreparedStatement; valideer input; beperk DB-privileges.

7) Troubleshoot een JDBC-verbindingsfout.

Verwacht antwoord: Controleer URL, credentials, netwerk, driver-jar; bekijk logs; corrigeer verkeerd geconfigureerde poort.

8) Transacties in JDBC managen.

Verwacht antwoord: Auto-commit uitschakelen, operaties uitvoeren, commit of rollback op basis van uitkomst; zorgt voor ACID-compliance.

9) Uitdagend DB-probleem oplossen met JDBC.

Verwacht antwoord: Batchverwerking geïmplementeerd voor bulk-inserts, tijd teruggebracht van minuten tot seconden.

10) JDBC-verbeteringen prioriteren onder dode lijnen.

Verwacht antwoord: Impact beoordelen, duidelijk communiceren, hoog-impact items eerst aanpakken, samenwerken om SLA te halen.