Spring Boot + Apache Kafka Course - The Practical Guide

Install and set up Apache Kafka locally by downloading, extracting, and renaming the folder, then start ZooKeeper and the Kafka broker on localhost 9092.

Create and set up a Spring Boot project in IntelliJ using Spring Initializr, add Spring Web and Spring for Apache Kafka dependencies, import, and run on port 8080.

Configure kafka producer and consumer in a Spring Boot application using auto-configuration and external properties. Set up application.properties with bootstrap-servers, group-id, auto-offset-reset earliest, and key/value serializers to enable seamless messaging.

Learn to build a Kafka producer with Spring Boot by injecting a KafkaTemplate and sending a message to the javaguides topic, with logging.

Configure Kafka producer and consumer to use json serializer and deserializer by updating application.properties, switching value deserializers and serializers to json from Spring Kafka, and enabling trusted packages for json.

Create a Spring Kafka producer to send a JSON message using KafkaTemplate, log the user payload, and publish to the javaguides topic.

create a Kafka consumer to consume json messages with Spring Kafka, using the Kafka listener on the javaguides_json topic with group-id myGroup, logging user objects in a Spring Boot app.

Implement a Wikimedia producer by wiring a Spring service, using a Kafka template, and streaming real-time Wikimedia changes via an event source to a Kafka topic.

Run a Spring Boot application that triggers a Wikimedia producer to emit messages to a Kafka topic, setting up ZooKeeper and broker for a real-time streaming demo.

Create a Spring Boot Kafka consumer module in the parent project and add a main class to run it, ready to consume data from the capture broker.

Configure a spring boot kafka consumer in application.properties to connect to the broker, set a consumer group, and specify key and value deserializers for real-time topic data.

Configure a Kafka consumer in a Spring Boot application, subscribing to the capture topic with a group id, and log each message received to verify real-time data flow.

Learn to save Wikimedia data to a MySQL database with Spring Boot and Apache Kafka, using a JPA entity and repository to store real-time events.

Externalize hard coded topic names via application properties and @Value, replacing code literals in Wikimedia and consumer projects to enable consistent configuration.

Explore how event-driven architecture uses decoupled microservices that publish and subscribe to events via a message broker, enabling asynchronous communication and loose coupling among order, stock, and email services.

Learn event-driven microservices with Spring Boot and Apache Kafka, using a single topic for multiple consumers. Build order, stock, and email services that publish and consume OrderEvent asynchronously.

Create four independent Spring Boot microservices OrderService, StockService, EmailService, and BaseDomains using Spring Initializr and Maven with Web and Kafka dependencies, then import into IntelliJ.

Import four Spring Boot projects into a single IntelliJ workspace and create a parent project with four modules. Run the three microservices on ports 8080, 8081, and 8082.

Configure the order service as a Kafka producer to publish events. Configure bootstrap servers, key/value serializers, and the topic name order_topics, and run Zookeeper and Kafka locally.

Configure a Kafka topic in a Spring Boot order service by retrieving the topic name from application.properties and exposing a topic bean with TopicBuilder.

Create a Spring order producer that sends OrderEvent messages to a Kafka topic using KafkaTemplate, with a topic header and SLF4J logging.

Create a rest api to place orders, assign a uuid, build an OrderEvent with pending status, and send it via OrderProducer to a Kafka topic through the /api/v1/orders endpoint.

Configure a Kafka consumer in the stock service with Spring Boot properties, including bootstrap servers, group-id, and auto-offset-reset. Consume messages from the order_topics topic using json deserializers and Spring Kafka.

Showcases an end-to-end event-driven microservices demo in which the order service publishes to the order_topics Kafka topic and stock and email services consume the events.

Kafka producers create messages, send them to a topic, choose a partition by manual selection, key-based routing, or round robin, and await 0, 1, or all acknowledgments.

Learn how a consumer group coordinates multiple consumers to read messages from a Kafka topic, with partitions assigned so each partition is processed by one consumer, and groups read independently.

Explore how producers send data to a Kafka cluster, where topics split into partitions and replicas on brokers enable fault tolerance, while consumers in groups read in parallel high throughput.

Discover how Kafka achieves high throughput and low latency by using sequential disk writes, zero-copy, partitions, and batching, plus memory caching and horizontal scaling.

Explore how Kafka ensures message durability through disk writes, multi-broker replication with in-sync replicas, strong acknowledgments, immutable logs, kraft metadata durability, and flexible retention policies.

Discover how Kafka achieves fault tolerance through cross-broker replication, leader-follower switching, in-sync replicas, safe write acknowledgments, automatic rebalancing, and KRIFT metadata replication.

Explore Kafka topics, partitions, brokers, replication, and Zookeeper role for fault-tolerance; and learn producers, consumers, offsets, consumer groups, exactly-once semantics, transactions, streams, retention, and log compaction.