Learn Java Messaging and Event Streaming

Mental model mendalam untuk broker, queue, topic, log, stream, partition, offset, subscription, dan consumer group pada JMS/Jakarta Messaging, Kafka, RabbitMQ, dan RabbitMQ Streams.

Delivery Guarantees and Failure Taxonomy

Taxonomy mendalam untuk delivery guarantees, failure modes, duplicates, loss, reordering, poison messages, retries, acknowledgements, offset commit, and effectively-once engineering.

Jakarta Messaging/JMS API, Contracts, and Runtime Model

Deep dive into Jakarta Messaging/JMS API contracts, object model, destination model, message anatomy, lifecycle, portability boundaries, and production design heuristics.

JMS Sessions, Transactions, Acknowledgement, and Redelivery

14 min

Deep dive into JMS/Jakarta Messaging sessions, acknowledgement modes, transactions, redelivery, poison message handling, and production failure semantics.

JMS Message-Driven Architecture in Jakarta EE

16 min

Message-driven architecture with Jakarta Messaging/JMS in Jakarta EE: MDB lifecycle, container-managed concurrency, transaction boundaries, listener design, operational invariants, and production anti-patterns.

JMS Request-Reply, Correlation, Selectors, and Temporary Destinations

Deep dive into JMS request-reply, correlation IDs, JMSReplyTo, temporary destinations, selectors, timeout handling, orphan replies, and anti-patterns in synchronous-over-asynchronous messaging.

RabbitMQ Core Routing Model

RabbitMQ core routing model for Java engineers: exchange, queue, binding, routing key, publisher, consumer, acknowledgement, confirms, topology design, and operational failure modes.

RabbitMQ Queue Types and Trade-Offs

RabbitMQ queue types and operational trade-offs: classic queues, quorum queues, lazy behavior, priority queues, queue length limits, overflow, replication, durability, and failure modelling.

RabbitMQ Consumer Design: Prefetch, Ack, Nack, Requeue, and Backpressure

Advanced RabbitMQ consumer design covering manual acknowledgement, prefetch, nack/reject, requeue behaviour, backpressure, batching, idempotency, concurrency, and production failure modelling.

RabbitMQ Reliability: Publisher Confirms, Mandatory Routing, DLX, TTL, and Retries

14 min

Advanced RabbitMQ reliability design covering publisher confirms, mandatory routing, alternate exchanges, durable publishing, DLX, TTL-based retry, poison message quarantine, retry budgets, and Java implementation patterns.

RabbitMQ Streams Log-Based Messaging

RabbitMQ Streams deep dive: append-only log semantics, stream declaration, retention, producer/consumer API, offset tracking, deduplication, batching, and operational boundaries.

RabbitMQ Superstreams, Partitioning, and Scaling

RabbitMQ Superstreams deep dive: partitioned streams, routing keys, ordering per partition, single active consumer, offset tracking, scaling model, and operational failure modes.

RabbitMQ Stream Filtering, Deduplication, and Performance Testing

RabbitMQ Streams advanced features: stream filtering, deduplication, offset interaction, benchmark discipline, Stream PerfTest, and production performance failure modes.

Kafka Core Architecture

17 min

Apache Kafka core architecture: broker, topic, partition, record batch, offset, log segment, retention, replica, ISR, leader/follower, controller, producer path, and consumer path.

Kafka Producer Internals, Batching, Linger, Compression, Acks, and Idempotence

Kafka producer internals in Java: ProducerRecord, key, partitioner, accumulator, batching, linger, compression, acks, retries, delivery timeout, idempotence, transactions boundary, and production tuning.

Kafka Consumer Internals, Poll Loop, Rebalance, and Commit

13 min

Kafka consumer internals in Java: poll loop, fetch, consumer groups, assignment, heartbeat, session timeout, max poll interval, offset commit, rebalance listener, backpressure, and safe processing patterns.

Kafka Ordering, Partitioning, Keys, and Hotspot Avoidance

17 min

Kafka ordering, partitioning, message keys, entity affinity, hot partition avoidance, repartitioning strategy, and business-order correctness for Java event-driven systems.

Kafka Reliability, Transactions, and Exactly-Once Boundaries

14 min

Kafka reliability, replication, durability, producer idempotence, transactions, consume-process-produce workflows, exactly-once semantics boundaries, and production failure modelling.

Kafka Error Handling, Retry, DLQ, and Poison Events

Kafka error handling, retry strategy, dead-letter topics, poison events, quarantine, replay, ordering trade-offs, and production recovery design.

Kafka Schema Discipline: JSON, Avro, Protobuf, Schema Registry, and Compatibility

Kafka schema discipline with JSON, Avro, Protobuf, Schema Registry, compatibility modes, event envelopes, semantic versioning, and contract governance.

Kafka Streams in Java: Topology, KStream, KTable, GlobalKTable, State Store

Kafka Streams in Java, topology design, KStream, KTable, GlobalKTable, state stores, changelog topics, standby replicas, internal topics, lifecycle, operational failure modes, and production-grade topology invariants.

Kafka Streams Joins, Windows, Suppression, and Event-Time Reasoning

Kafka Streams joins, event-time processing, timestamp extraction, stream-stream joins, stream-table joins, table-table joins, tumbling/hopping/sliding/session windows, grace periods, suppression, late events, and operational design for time-aware stream processing.

ksqlDB Mental Model

ksqlDB mental model: declarative stream processing on Kafka, streams, tables, materialized views, persistent queries, push queries, pull queries, and when SQL-based streaming is or is not the right abstraction.

ksqlDB Query Design

21 min

ksqlDB query design for streams, tables, joins, aggregations, repartitioning, key formats, value formats, query plans, output contracts, and production-safe SQL design.

ksqlDB Operations, Scaling, State, Lag, and Metrics

25 min

ksqlDB operations for deployment, scaling, state management, lag, metrics, high availability, recovery, rollout discipline, and production runbooks.

Technology Decision Matrix

21 min

Decision matrix for choosing between Jakarta Messaging/JMS, Kafka, RabbitMQ queues, RabbitMQ Streams, and ksqlDB based on semantics, reliability, replay, routing, ordering, throughput, governance, and operational trade-offs.

Pipelining and Batching: Throughput Engineering Across Messaging Systems

23 min

Throughput engineering across JMS/Jakarta Messaging, Kafka, RabbitMQ queues, RabbitMQ Streams, Kafka Streams, and ksqlDB using pipelining, batching, compression, buffering, concurrency, and realistic benchmark discipline.

Backpressure and Flow Control: Keeping the System Stable Under Load

22 min

Backpressure and flow-control stability across Kafka, RabbitMQ, RabbitMQ Streams, JMS/Jakarta Messaging, Kafka Streams, and ksqlDB, with control-loop reasoning, metrics, alerts, and production runbooks.

Idempotency, Deduplication, Inbox/Outbox, and Transactional Messaging

Idempotency, deduplication, inbox/outbox, transactional messaging, external side-effect protection, and regulatory-grade reliability across JMS, Kafka, RabbitMQ, RabbitMQ Streams, Kafka Streams, and ksqlDB.

Observability: Metrics, Logs, Traces, Lag, Correlation, and Causality