CF

Event-Driven Microservices, CQRS, SAGA, Axon, Spring Boot

8h 55m 3s
English
Paid

Learn how to build event-driven microservices with Spring Boot and Axon. This course starts at the basics and guides you step by step. You will build simple services first, then connect them, scale them, and add stronger design patterns.

Microservice Basics

You start by creating your first Spring Boot microservice. You learn how to handle HTTP requests and return clear responses. You then run several service instances behind an API Gateway. This helps your services scale when traffic grows.

You also learn how service discovery works. This makes each service easy to find and call inside your system.

Distributed Transactions

Many systems need a flow that touches more than one service. You learn how to build this flow with safe steps. You also learn how to roll back changes when something fails. This prepares you for larger and more complex systems.

Event-Driven Design

The course shows how to shift from request-driven code to event-based microservices. Event messages let services react to changes without knowing each other’s location. This keeps your system flexible and easier to grow.

Axon Framework

You use Axon to build these event-driven features. Axon is built on CQRS and DDD. You learn how to separate commands and queries, store events, and rebuild state from past events.

Saga Pattern

You finish by learning the Saga pattern. A Saga groups several steps into one long process. It also handles failures and rolls back work when needed. This helps you run business logic across many microservices with clear control.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 148 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 148 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (148)
#Lesson TitleDurationAccess
1
Introduction Demo
03:52
2
Microservice vs Monolithic application
07:12
3
Microservices Architecture Overview
07:40
4
Event-Driven Microservices
05:17
5
Transactions in Microservices
04:32
6
Choreography-Based Saga
05:52
7
Orchestration-Based Saga
04:29
8
Frameworks that we can use
02:54
9
(CQRS)Command Query Responsibility Segregation
07:09
10
Event Sourcing
07:12
11
Axon Framework and Axon Server
03:01
12
Download and run Docker Desktop
04:16
13
Spring Tool Suite
02:42
14
Download and Install Postman HTTP client
02:20
15
Creating a new project. Products Microservice.
05:32
16
Creating a Rest Controller class
04:41
17
Handle HTTP POST, GET, PUT and DELETE Requests
04:44
18
Trying how it works
01:48
19
Introduction
04:30
20
Creating new project
03:33
21
Configure project as Eureka Server
05:57
22
Registering Microservices with Eureka
06:03
23
Trying how it works
02:26
24
Introduction
03:45
25
Creating Spring Cloud API Gateway project
05:25
26
Automatic Routing with Resource Locator
05:42
27
Random Port Number
05:24
28
Starting Multiple instances of Products Microservice
06:13
29
Trying how load balancing work
05:36
30
Download and run Axon Server as JAR application
04:08
31
Axon Server configuration properties
07:06
32
Run Axon Server in a Docker container
08:25
33
Start, Stop, Delete Axon Server Docker Container By ID
04:22
34
Configure Axon Server running in Docker Container
02:50
35
Accept HTTP Request Body
04:35
36
Trying how it works
00:53
37
Adding Axon Framework Spring Boot Starter
00:57
38
Creating a new Command class
04:27
39
Creating a new CreateProductCommand object
01:52
40
Send Command to a Command Gateway
04:13
41
Product Aggregate - Introduction
02:11
42
Creating ProductAggregate class
02:12
43
Validate the CreateProductCommand
01:16
44
Creating ProductCreatedEvent
02:54
45
Apply and Publish the Product Created Event
03:04
46
@EventSourcingHandler
03:08
47
Adding Additional Dependency
01:43
48
Trying how it works
03:35
49
Previewing Event in the EventStore
02:38
50
Introduction
00:41
51
Adding Spring Data JPA & H2 dependencies
03:03
52
Configure database access in the application.properties file
04:30
53
Creating an ProductEntity
05:11
54
Creating ProductRepository
03:53
55
Creating Products Events Handler/Projection
02:16
56
Implementing @EventHandler method
01:42
57
Trying how it works
02:29
58
Preview Product record in a database
03:27
59
Introduction
00:51
60
Creating Rest Controller
02:22
61
Refactor Command API Rest Controller
01:56
62
Get Products web service endpoint
02:48
63
Querying the QueryGateway
05:04
64
Creating ProductsQueryHandler
01:28
65
Implementing the findProducts() method
03:31
66
Trying how it works
01:29
67
Introduction to Bean Validation
03:48
68
Bean validation. Enable Bean Validation.
02:52
69
Bean validation. Validating Request Body.
05:42
70
Trying how the Request Body Validation works.
02:57
71
Introduction
00:40
72
Command validation in the Aggregate
01:27
73
Introduction to Message Dispatch Interceptor
01:21
74
Creating a new Command Interceptor class
05:15
75
Register Message Dispatch Interceptor
02:04
76
Trying how the Command Interceptor works.
05:53
77
Set Based Consistency - Introduction
05:17
78
Creating Product Lookup Entity
03:30
79
Creating Product Lookup Repository
02:25
80
Creating a ProductLookupEventsHandler
05:45
81
Persisting information into a ProductLookup table
02:09
82
Updating MessageDispatchInterceptor
03:28
83
Trying how the Set base validation works
04:05
84
Introduction
06:08
85
Creating a centralized Error Handler class
05:03
86
Trying how the centralized error handler class works
02:27
87
Return custom error object
03:25
88
Handle the @CommandExecutionException
03:26
89
Trying to handle the @CommandExecutionException
03:31
90
@ExceptionHandler
03:15
91
Creating the ListenerInvocationErrorHandler
03:49
92
Register the ListenerInvocationErrorHandler
03:28
93
Trying how transaction rollback works
07:43
94
Introduction
02:18
95
Saga class structure overview
03:42
96
Creating OrderSaga class
01:57
97
@SagaEventHandler method for the OrderCreatedEvent
02:44
98
Creating a new Core API module
03:38
99
Adding Core project as a dependency to OrdersService
01:24
100
Creating the ReserveProductCommand
01:42
101
Publish the ReserveProductCommand
02:18
102
Handle the ProductServeCommand in the ProductsService
03:32
103
Publish the ProductReservedEvent
02:42
104
Updating Products projection
01:55
105
Handle the ProductReservedEvent in Saga
01:16
106
Trying how it works
05:39
107
Introduction
02:24
108
Fetching User Payment Details
03:25
109
Trying how it works
02:12
110
Creating the ProcessPaymentCommand
01:51
111
Publish the ProcessPaymentCommand
03:08
112
Handle the PaymentProcessedEvent
01:24
113
Create and publish the ApproveOrderCommand
02:32
114
Handle the ApproveOrderCommand
01:24
115
Create and publish the OrderApprovedEvent
03:19
116
Handle the OrderApprovedEvent and update Orders database
02:24
117
Handle the OrderApprovedEvent in OrderSaga class
02:22
118
Trying how it works
02:58
119
Introduction
03:17
120
Creating the CancelProductReservation command
02:03
121
Publish the CancelProductReservationCommand
04:11
122
Handle the CancelProductReservation command in ProductsService
01:07
123
Create and publish the ProductReservationCancelledEvent
01:29
124
Handle the ProductReservationCancelledEvent
04:56
125
Create and publish the RejectOrderCommand
02:13
126
Handle the RejectOrderCommand on the query side
00:44
127
Create, publish and handle the OrderRejectedEvent
04:23
128
Trying how it works
10:00
129
Introduction
04:37
130
Creating a DeadlineManager object
02:50
131
Schedule a deadline
05:31
132
Handle deadline
03:32
133
Cancel deadline
04:03
134
Trying how it works
03:33
135
Introduction
03:07
136
Creating the FindOrderQuery
01:13
137
Creating the QueryHandler method
03:48
138
Sending a Subscription Query
04:00
139
Emit an Update to the subscription query
04:33
140
Trying how it works
04:36
141
Introduction
06:12
142
Configure Snapshotting
03:40
143
Trying how it works
07:40
144
Introduction
05:34
145
@ResetHandler
02:21
146
Replay Events Endpoint
02:53
147
Starting the Replay of Events
02:59
148
Trying how it works
05:58
Unlock unlimited learning

Get instant access to all 147 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course is designed for individuals who have a basic understanding of Java and Spring Boot. Familiarity with microservices architecture would be beneficial but not mandatory. The course starts with fundamental concepts, making it accessible to those new to event-driven microservices but with some programming background.
What projects will I build during the course?
You will start by creating a Spring Boot microservice, learning to handle HTTP requests and responses. As the course progresses, you will connect multiple services, implement service discovery, and work with an API Gateway. You will also build event-driven features using the Axon Framework and implement the Saga pattern for managing complex business processes.
Who is the target audience for this course?
The course is aimed at software developers and architects interested in building scalable, event-driven microservices. It is suitable for those who want to learn how to implement distributed transactions, event sourcing, and CQRS using Spring Boot and the Axon Framework.
How does the depth of this course compare to similar offerings?
This course offers a detailed exploration of event-driven microservices, focusing on Axon Framework, CQRS, and the Saga pattern. With 148 lessons, it provides a step-by-step guide from basic concepts to complex system design, making it more comprehensive than courses that only cover introductory topics.
What specific tools and platforms will I learn to use?
You will work with Spring Boot for building microservices and the Axon Framework for implementing event-driven design. The course also covers Docker for container management, Eureka for service discovery, and Spring Cloud Gateway for API management. Additionally, you will use Postman for testing HTTP requests.
What key topics are not covered in this course?
The course does not cover advanced topics in machine learning, data science, or frontend development. It strictly focuses on backend development using event-driven microservices, Spring Boot, and Axon Framework, without delving into security practices or database optimization techniques beyond basic configurations.
How much time should I expect to commit to completing this course?
The course comprises 148 lessons, and while the total runtime is not specified, students should allocate several weeks for completion, depending on their pace and prior experience. Each lesson includes practical exercises, so students should account for additional time to implement and experiment with the concepts taught.