inflearn logo

RabbitMQ Practical Use Cases

Learn the principles and practical patterns of solving coupling issues in synchronous calls using message brokers. Through a shopping mall scenario, you will systematically master reliable asynchronous system design methods, ranging from Exchange, Queue, and Binding structures to retries, DLQ, idempotency, and the Transactional Outbox pattern. You will also understand the boundaries between RabbitMQ and Kafka and establish criteria for the appropriate use of message queues.

7 learners are taking this course

Level Intermediate

Course period Unlimited

Java
Java
Spring Boot
Spring Boot
rabbitmq
rabbitmq
system-design
system-design
asynchronous-programming
asynchronous-programming
Java
Java
Spring Boot
Spring Boot
rabbitmq
rabbitmq
system-design
system-design
asynchronous-programming
asynchronous-programming

What you will gain after the course

  • Designing Message Broker-Based Asynchronous Architecture and Distinguishing 5 Messaging Patterns

  • Understanding reliability assurance mechanisms such as Retries, DLQ, Idempotency, and Transactional Outbox.

  • Establishing criteria for message queue adoption and guidelines for choosing between RabbitMQ and Kafka

🤔 That moment when you clicked the sign-up button, but the screen froze for 3 seconds

You've probably had an experience like this at least once. When a sign-up request comes in, you save the user to the database and then send a welcome email. It worked perfectly in the local environment. However, after deploying to production, sign-up responses suddenly start taking 3 or 5 seconds. Upon investigating the cause, it turns out the email server had just slowed down briefly. Our service was fine, but our users were stuck staring at a loading spinner because of someone else's server issues.

When the payment provider slows down, orders slow down; when image conversion takes a long time, uploads stop. The phenomenon where tasks that should be independent are tied together in a single line, holding each other back — RabbitMQ is the tool that cuts this knot. However, when you actually try to learn it, you hit a wall. "There are so many patterns, but when should I use which one?", "I turned on retries and ended up with a double payment?", "I changed everything to queues for now, but it actually became more complex."

This course overcomes those barriers through concepts and judgment.

📌 This is how the course will proceed

This is a concept-oriented lecture. There are no hands-on coding exercises to follow along with.

In an era where AI writes code for you, true skill does not come from memorizing syntax. It comes from the insight to judge "why, when, and with what pattern this task should be handled." That insight is exactly what this lecture aims for.

  • We provide well-organized lecture materials and explain concepts and flows while viewing slide images created from those materials.

  • Example code appears only as material to understand "why it is written this way" — there is no need to set up an environment or type along by hand.

  • What remains after taking this course is not a finished project, but a judgment framework for which pattern to use in which situation and why.

✨ Why this course is special

🗺️ 1. A single shopping mall scenario runs through all 20 lectures

Concepts are not scattered. A simple CRUD shopping mall, ShopMQ, grows throughout the entire course. You will change notifications to asynchronous → offload image conversion to a Worker → decouple post-order tasks into events → isolate payment failures → and even implement real-time browser notifications. Because you encounter patterns within a single context, you will naturally understand "why each concept is necessary in this exact spot."

🎯 2. A single decision frame that threads through all patterns

"Respond now, process later, and retry failures."

These three elements form the backbone of the entire course. The moment you realize that the 12 patterns are actually variations of these principles, even when you encounter a new situation not covered in the course, you will be able to find the answer yourself by asking, "Which of these three elements does this fall into?"

🛡️ 3. It doesn't end with "Sending a Message"

Most queue courses stop at publishing and consuming. However, in practice, real incidents occur beyond that point. This course covers reliability and resilience in depth across an entire section — exponential backoff retries, DLQ (Dead Letter Queue), idempotency, Transactional Outbox, and ACK policies. It answers questions like "Why must retries and idempotency always be paired?" and "Why do events disappear silently?" based on core principles.

🧭 4. It even teaches you when 'not to use' it

Once you learn about queues, you'll want to solve everything with them. However, queues also come with a cost. This course honestly addresses cases of overuse and misuse, as well as the boundaries between RabbitMQ ↔ Kafka ↔ dedicated schedulers. The judgment to avoid the situation where "adding a queue actually made things more complex" is the most practical weapon this course provides.

🃏 The unique cheat code of this course

① 20 lectures through a single shopping mall project · ② Three-step decision-making framework · ③ Deep dive into reliability and resilience · ④ When to avoid it and the boundaries with Kafka

🎓 What you will be able to do after completing this course

  • You can clearly explain the coupling (performance, failure, scalability, change) issues created by synchronous calls.

  • You can distinguish between Exchange·Queue·Binding and the five messaging patterns: Work Queue·Pub/Sub·Routing·Topic·RPC.

  • When faced with a new task, you will be able to determine for yourself whether "this is something that should be passed to a queue" by asking three specific questions.

  • Distinguish between events and commands, and develop a design sense for decoupling services using Fanout/Topic routing.

  • Understand how retries, DLQ, idempotency, and Outbox pair together to create reliability.

  • Understand the boundaries between RabbitMQ and other tools, and develop the insight to avoid overuse and misuse.

🚀 The eye for judgment must still be yours

What this course provides is not just a "working shopping mall," but a framework of thinking that naturally makes you ask, "Is this something that should be passed to a queue?" when faced with a new task.

AI will fill in the detailed syntax. However, the eye for judging what to build and why must still be yours. Let's cultivate that vision together.

Recommended for
these people

Who is this course right for?

  • A back-end developer who has experience in Spring Boot CRUD development and is considering the introduction of an asynchronous messaging system.

  • Junior and mid-level developers who want to systematically organize RabbitMQ concepts and practical patterns.

  • Developers who need to learn system design interviews and microservices architecture

Need to know before starting?

  • Experience with basic Java syntax and the Spring Boot framework

  • Understanding RESTful API development and HTTP communication methods

  • Basic concepts of JPA and fundamental knowledge of database transactions

Hello
This is oncoding

708

Learners

13

Reviews

20

Answers

4.3

Rating

8

Courses

Curriculum

All

22 lectures ∙ (6hr 13min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

Not enough reviews.
Please write a valuable review that helps everyone!

oncoding's other courses

Check out other courses by the instructor!

Similar courses

Explore other courses in the same field!

Limited time deal ends in 8 days

$13.20

25%

$17.60