Learn Java Data Access Pattern In Action

Responsibility map untuk DAO, Repository, Gateway, Unit of Work, Query Service, Transaction Script, dan boundary data access Java production-grade.

Relational Access From Java

Memahami bagaimana Java benar-benar berinteraksi dengan database relasional melalui JDBC primitive: DataSource, Connection, Statement, PreparedStatement, ResultSet, transaksi, mapping, dan failure boundary.

Anti-Patterns That Destroy Data Layers

21 min

Membongkar anti-pattern yang sering menghancurkan data access layer Java: repository bocor, entity bocor, N+1, transaksi kabur, generic repository, SQL tidak ter-review, error swallowing, dan testing palsu.

SQL-First vs Object-First vs Domain-First

Membandingkan pendekatan SQL-first, object-first, dan domain-first dalam data access Java, termasuk trade-off, failure mode, dan cara memilih pendekatan yang tepat untuk sistem production-grade.

Data Access Decision Framework

Framework keputusan untuk memilih JDBC, JPA, Hibernate, MyBatis, jOOQ, R2DBC, stored procedure, read model, atau kombinasi pattern data access Java secara production-grade.

Data Access Architecture Map

19 min

Peta arsitektur data access Java untuk monolith, modular monolith, microservice, batch worker, dan API backend, dengan fokus pada boundary, ownership, query shape, transaction scope, dan evolusi sistem.

Production-Grade Data Access Invariants

Invariant production-grade untuk data access Java: correctness, idempotency, transaction boundary, query stability, timeout, resource lifecycle, observability, testing, dan migration safety.

JDBC Core API

Deep dive JDBC core API sebagai primitive dasar data access Java: DriverManager, DataSource, Connection, Statement, PreparedStatement, CallableStatement, ResultSet, metadata, transaction, lifecycle, dan architecture boundary.

PreparedStatement and Parameter Binding

PreparedStatement dan parameter binding secara production-grade: SQL injection prevention, placeholder semantics, type binding, dynamic SQL, generated keys, batch execution, query naming, plan reuse, dan failure modes.

ResultSet Mapping Patterns

Pola mapping ResultSet ke DTO, row object, domain object, dan aggregate secara aman: nullability, type conversion, one-to-many mapping, projection, mapper contract, error handling, dan testing.

JDBC Transaction Control

Kontrol transaksi JDBC secara mendalam: auto-commit, commit, rollback, savepoint, isolation, transaction boundary, failure path, retry boundary, idempotency, connection lifecycle, dan production-grade transaction template.

JDBC Error Handling

20 min

Error handling JDBC secara production-grade: SQLException, SQLState, vendor code, transient vs non-transient error, constraint violation, deadlock, timeout, connection failure, retry policy, idempotency, dan semantic exception mapping.

JDBC Resource Lifecycle

20 min

Lifecycle resource JDBC secara production-grade: Connection, PreparedStatement, ResultSet, try-with-resources, pooled connection state, leak pattern, cancellation, timeout, streaming, transaction cleanup, and operational diagnostics.

JDBC Batch and Bulk Write

Batch dan bulk write JDBC secara production-grade: addBatch, executeBatch, chunking, transaction sizing, generated keys, partial failure, BatchUpdateException, idempotency, upsert, staging table, lock pressure, dan observability.

JDBC Streaming Large Result

21 min

Streaming large result JDBC secara production-grade: ResultSet cursor, fetch size, driver behavior, transaction scope, memory safety, callback vs Stream, chunking, export, cancellation, timeout, backpressure illusion, dan operational playbook.

Transaction Boundary Design

17 min

Desain transaction boundary pada Java application: service layer, use case, command handler, repository, async boundary, outbox, audit, retry, idempotency, dan consistency boundary secara production-grade.

Isolation Level In Practice

19 min

Isolation level dalam praktik Java data access: read committed, repeatable read, serializable, dirty read, non-repeatable read, phantom, lost update, write skew, predicate anomaly, retry, locking, dan invariant design.

Locking Patterns

Pola locking dalam Java data access: optimistic lock, pessimistic lock, SELECT FOR UPDATE, advisory lock, application lock, lease lock, deadlock prevention, lock timeout, SKIP LOCKED, dan kapan lock lebih tepat daripada constraint atau state machine.

Idempotent Write Pattern

20 min

Idempotent write pattern untuk Java data access: idempotency key, command ID, unique constraint, dedup table, replay-safe result, request retry, message redelivery, outbox/inbox dedup, exactly-once illusion, dan production-grade implementation.

Concurrency Anomaly Lab

Lab anomaly concurrency untuk Java data access: double spending, duplicate approval, stale state transition, concurrent assignment, lost update, phantom, write skew, test dua connection, barrier/latch, dan cara membuktikan fix dengan constraint, version, lock, dan serializable.

Transaction Retry Pattern

Transaction retry pattern untuk Java data access: deadlock, serialization failure, transient connection issue, retry budget, exponential backoff, jitter, deadline, idempotency, whole-transaction retry, outbox, side-effect safety, dan observability.

Long-Running Transaction Avoidance

Menghindari long-running transaction dalam Java data access: split phase, status machine, reservation, compensation, durable progress, async workflow, file/external service boundary, batch checkpoint, dan failure recovery.

Consistency Without Distributed Transaction

Mendesain consistency tanpa distributed transaction: local transaction, transactional outbox, inbox/idempotent consumer, saga boundary, compensation, eventual consistency, exactly-once illusion, read model lag, reconciliation, dan Java implementation patterns.

DAO Pattern Done Right

DAO pattern modern yang benar dalam Java data access: contract, SQL ownership, mapping, transaction participation, error translation, query naming, batching, testing seam, dan anti-pattern DAO generik.

Repository Pattern Done Right

Repository pattern modern dalam Java: aggregate boundary, collection illusion, mutation semantics, persistence ignorance, DAO composition, transaction boundary, optimistic locking, query limitation, testing, dan anti-pattern generic repository.

Query Object and Specification Pattern

Query Object dan Specification Pattern dalam Java data access: filter object, sorting, pagination, keyset cursor, composable predicate, criteria, dynamic SQL, query ownership, validation, tenant scope, dan testing.

Command Query Separation in Data Access

Command Query Separation dalam Java data access: memisahkan write repository dan read/query service, pragmatis tanpa overengineering CQRS, DTO projection, read model, transaction boundary, consistency lag, dan testing.

DTO Projection and Read Model

DTO projection dan read model dalam Java data access: view model, reporting query, list screen optimization, avoiding entity leak, direct projection, constructor mapping, database view, denormalization, projection lag, rebuild, dan testing.

Data Mapper vs Active Record

Data Mapper vs Active Record dalam Java enterprise: persistence model, domain separation, ORM, transaction boundary, testing, complexity trade-offs, why Java often prefers Data Mapper, and when Active Record is acceptable.

Unit of Work, Identity Map, Lazy Loading

Unit of Work, identity map, dirty checking, lazy loading, flush boundary, persistence context, entity state, N+1, detached entity, dan production failure modes pada Java data access.

Data Access Contract Design

Desain kontrak method data access Java: naming, return type, nullability, Optional, collection, stream, pagination, cursor, update count, error semantics, transaction expectation, locking, idempotency, dan API review rubric.

JPA Entity Modeling for Data Access

Entity modeling JPA untuk data access production: identity, lifecycle, association, embeddable, value object, aggregate boundary, table mapping, versioning, audit, invariants, dan anti-pattern entity design.

EntityManager and Persistence Context

EntityManager dan persistence context dalam JPA/Hibernate: managed, detached, transient, removed, persist, find, getReference, merge, remove, flush, clear, refresh, lock, transaction scope, dan failure modes production.

Hibernate Dirty Checking and Flush

Hibernate dirty checking dan flush secara production-grade: dirty state detection, flush mode, transaction boundary, unexpected update, write amplification, dynamic update, read-only transaction, batch flush/clear, dan observability.

JPA Mapping Association Patterns

Pola mapping association JPA production-grade: many-to-one, one-to-many, one-to-one, many-to-many avoidance, join entity, ownership, cascade, orphan removal, fetch strategy, collection type, ordering, dan failure modes.

Lazy Loading and N+1

Lazy loading dan N+1 problem dalam JPA/Hibernate: proxy, collection lazy load, fetch join, entity graph, batch size, subselect fetch, DTO projection, query count test, OSIV risk, dan production debugging.

Hibernate Query Patterns

Hibernate/JPA query patterns untuk production: JPQL, Criteria, native query, named query, DTO projection, tuple mapping, pagination, sorting, count query, fetch join, query hints, timeout, locking, dan reviewability.

JPA Locking and Versioning

JPA locking dan versioning untuk production: @Version, optimistic locking, stale update, optimistic force increment, pessimistic read/write, SELECT FOR UPDATE, lock timeout, deadlock, retry design, dan error mapping.

JPA Caching and Consistency

JPA/Hibernate caching dan consistency: first-level cache, second-level cache, query cache, natural-id cache, invalidation, stale reads, cache concurrency strategy, read-only/reference data, read model cache, dan production risks.

Hibernate Performance Tuning

Hibernate performance tuning untuk production: batch fetch, JDBC batch, insert/update ordering, read-only transaction, stateless session, fetch size, persistence context size, pagination, query count, indexing, dan tuning tanpa menyembunyikan desain buruk.

ORM Failure Modes

ORM failure modes dalam Java/JPA/Hibernate production: cartesian explosion, hidden query, detached entity confusion, cascade disaster, lazy exception, merge overwrite, stale persistence context, bulk bypass, equals/hashCode bug, dan prevention checklist.

jOOQ SQL-First Mental Model

jOOQ SQL-first mental model untuk Java data access production: generated schema, DSLContext, database-first workflow, type-safe SQL DSL, record, transaction, mapping, query ownership, dan kapan jOOQ lebih cocok daripada ORM.

jOOQ Query Building Patterns

9 min

jOOQ query building patterns untuk Java production: select, join, reusable condition, dynamic query, CTE, window function, keyset pagination, aggregation, exists, upsert, locking, plain SQL escape hatch, dan query reviewability.

jOOQ Record Mapping and DTO

10 min

jOOQ record mapping dan DTO untuk production Java: Record mapping, POJO mapping, constructor mapping, explicit mapper, converter, binding, enum/value object mapping, JSON mapping, nullability, left join, generated records, dan type safety.

jOOQ Transactions and Batching

jOOQ transactions dan batching untuk production Java: transaction boundary, Spring integration, rollback, batch bind, bulk insert, generated keys, returning, upsert, conflict handling, retry, timeout, dan performance trade-offs.

MyBatis Mapper Pattern

10 min

MyBatis mapper pattern untuk Java production: XML vs annotation, mapper interface, parameter object, dynamic SQL, resultMap, nested mapping, type handler, transaction integration, SQL ownership, dan testing.

SQL Ownership and Reviewability

SQL ownership dan reviewability untuk Java data access production: query naming, explain plan, schema coupling, generated SQL visibility, migration safety, regulatory defensibility, query catalog, performance budgets, dan code review rubric.

R2DBC Mental Model

R2DBC mental model untuk Java reactive data access: non-blocking relational access, Publisher/Flux/Mono, connection lifecycle, pooling, transaction operator, backpressure, mapping, timeout, retry, dan production caveats.

Reactive Data Access Tradeoffs

Trade-off reactive data access Java: kapan R2DBC masuk akal, kapan JDBC lebih benar, event loop, blocking trap, pool vs database bottleneck, virtual threads, debugging, transaction complexity, team readiness, dan decision framework.

Async Boundaries and Database Pressure

Async boundaries dan database pressure untuk Java production: queue, backpressure, rate limit, bulkhead, timeout, retry storm, pool exhaustion, worker concurrency, outbox/inbox pressure, load shedding, fairness, dan observability.

Virtual Threads and Data Access

Virtual threads dan data access Java: JDBC blocking dengan virtual threads, pool tetap bottleneck, structured concurrency, transaction boundary, timeout, pinning caveat, ThreadLocal, Spring integration, backpressure, dan decision framework vs R2DBC.

Database Migration Patterns

Database migration patterns untuk Java production: versioned migration, repeatable migration, checksum, schema history, expand-contract, backward compatibility, deploy ordering, locking, rollback, seed/reference data, dan migration safety.

Flyway Production Workflow

Flyway production workflow untuk Java: migration naming, versioning, schema history, baseline, validate, repair, callbacks, Java migration, repeatable migration, placeholders, multi-env safety, CI/CD, out-of-order, cherry-pick, dan operational runbook.

Liquibase Production Workflow

Liquibase production workflow untuk Java: changelog, changeset, idempotency, checksum, DATABASECHANGELOG, precondition, rollback, label, context, include, formatted SQL, XML/YAML/JSON, generateChangeLog, diff, documentation, dan multi-env migration safety.

Expand-Contract Database Change

Expand-contract database change untuk Java production: backward-compatible schema evolution, dual write, dual read, backfill, read switch, feature flag, validation, cleanup, rollback, old/new app compatibility, dan zero-downtime rollout.

Zero-Downtime Data Access Change

Zero-downtime data access change untuk Java production: deploy order, rolling deployment, old/new app compatibility, migration lock, feature flags, query switch, read model switch, rollback, observability, dan failure playbook.

Data Backfill and Repair Job

Data backfill dan repair job untuk Java production: chunking, resume cursor, idempotent update, throttling, progress table, audit trail, dry run, validation, error isolation, retry, kill switch, and operational safety.

Testing Data Access Layer

Testing data access layer untuk Java production: unit test, integration test, Testcontainers, migration test, transaction rollback test, fixture strategy, query count test, concurrency test, performance smoke test, dan production readiness validation.

Data Access Engineering Playbook