English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 77 lectures (11h 4m) | 5.27 GB
Develop Event Driven Microservices using Spring Boot, Axon framework, CQRS, Saga, Event Sourcing patterns
Unlock the power of modern, event-driven microservices architecture with Spring Boot and the Axon Framework in this hands-on, project-based course. Dive deep into advanced patterns like CQRS (Command Query Responsibility Segregation), Saga, Event Sourcing, and essential microservices design principles to build robust, scalable applications.
This course is designed for developers and architects eager to gain expertise in building complex, distributed systems using event-driven patterns. From designing domain-driven services to managing data consistency across services, you’ll learn to address real-world challenges while creating resilient and high-performance microservices.
What You’ll Learn:
- Event-Driven Architecture Fundamentals: Master the foundations of event-driven design and understand when to use it in microservices.
- Implementing CQRS: Understand the Command Query Responsibility Segregation (CQRS) pattern, separating read and write concerns for optimized performance and scalability.
- Handling Complex Business Transactions with Sagas: Learn to coordinate distributed transactions across multiple microservices using the Saga pattern, ensuring consistency without traditional locking mechanisms.
- Event Sourcing: Capture every state change in an event log for an immutable record of historical data and easier debugging, replay, and auditability.
- Database-per-Service Pattern: Maintain data independence for each microservice using separate databases, enabling easier scaling and independent deployment.
- API Composition Pattern: Create aggregated, composite APIs at the gateway level to simplify client interactions with multiple services.
- Materialized View Pattern: Use read-optimized views for efficient querying, ensuring responsive and scalable data access in CQRS-based applications.
- Transactional Outbox Pattern: Ensure data consistency by safely publishing events from within your transaction boundary, eliminating potential data synchronization issues.
Key Technologies Covered:
- Spring Boot: Build and deploy microservices with the popular Spring Boot framework.
- Axon Framework: Leverage the Axon Framework’s powerful toolkit to implement CQRS and event-sourcing patterns.
- Message Brokers: Integrate with message brokers for reliable event publishing.
- Microservices Best Practices: Use design principles, patterns, and tools to enhance resilience, performance, and scalability.
Hands-On Learning:
This course is packed with real-world examples, hands-on exercises, and guided projects to solidify your skills. You’ll walk away ready to apply these advanced patterns in real projects, design robust microservices, and tackle common challenges in event-driven architectures with confidence.
Who Should Enroll:
- Software developers and architects interested in advanced microservices design.
- Engineers seeking hands-on experience with CQRS, Saga, Event Sourcing, and other cutting-edge patterns.
- Developers looking to learn Spring Boot and the Axon Framework to build event-driven systems.
By the end of this course, you’ll be fully equipped to design and develop sophisticated, event-driven microservices that handle complex data consistency challenges with ease, providing a solid foundation for any high-scale, high-resilience distributed application.
Table of Contents
Database-per-service pattern
1 Course Introduction
2 Details of Source Code, PDF Content & other instructions for the course
3 Introduction to Database-per-service pattern
4 Cross Service queries challenge in microservices
5 Introduction to API composition pattern
6 IntelliJ IDEA Ultimate
7 Say Hello to your new AI Coding Companion
8 Understanding microservices code and setup – Part 1
9 Understanding microservices code and setup – Part 2
10 Understanding microservices code and setup – Part 3
11 Implementing API composition pattern using Spring Cloud Gateway – Part 1
12 Implementing API composition pattern using Spring Cloud Gateway – Part 2
13 Implementing API composition pattern using Spring Cloud Gateway – Part 3
14 Data Consistency and Complex Transactions challenge in microservices
15 Data duplication challenge in microservices
Understanding CQRS and Event Sourcing patterns- Theory
16 Introduction to CQRS pattern
17 Advantages and disadvantages of CQRS pattern
18 Introduction to Event sourcing pattern
Implementing CQRS and Event Sourcing patterns
19 Introduction to AxonIQ
20 Axon Server Setup Locally Using Docker
21 Adding Axon framework dependencies inside microservices
22 Creating command classes in customer microservice
23 Creating query and event classes in customer microservice
24 Building command APIs in customer microservice
25 Technical flow of CQRS & ES
26 Creating aggregate class in customer microservice
27 Creating EventSourcingHandler method in customer aggregate class
28 Building update and delete customer logic in customer aggregate class
29 Building projection class in customer microservice
30 Building query API in customer microservice
31 Demo of CQRS and Event Sourcing in customer microservice
32 Axon Framework IntelliJ plugin
33 Performing validations using MessageDispatchInterceptor implementation – Part 1
34 Performing validations using MessageDispatchInterceptor implementation – Part 2
35 Reading data from EventStore
36 Event Processors in Axon framework – Part 1
37 Event Processors in Axon framework – Part 2
38 Event Processors in Axon framework – Part 3
39 Implementing CQRS and ES in accounts microservice – Part 1
40 Implementing CQRS and ES in accounts microservice – Part 2
41 Implementing CQRS and ES in cards, loans microservice
42 Different approaches to implement CQRS
Materialized View Pattern
43 Why we need to consider Materialized View Pattern
44 Introduction to Materialized View Pattern
45 What we are going to build with Materialized View Pattern
46 Implementing Materialized View Pattern – Part 1
47 Implementing Materialized View Pattern – Part 2
48 Implementing Materialized View Pattern – Part 3
49 Implementing Materialized View Pattern – Part 4
50 Implementing Materialized View Pattern – Part 5
51 Transactional Outbox Pattern
Choreography Saga pattern
52 Problem that Saga pattern solves
53 Introduction to Saga pattern
54 Benefits and drawbacks of Saga Pattern
55 What we are going to build using Choreography Saga Pattern
56 Implementing choreography saga pattern – Part 1
57 Implementing choreography saga pattern – Part 2
58 Implementing choreography saga pattern – Part 3
59 Implementing choreography saga pattern – Part 4
60 Demo of Saga pattern happy flow
61 Implementing compensation transactions – Part 1
62 Implementing compensation transactions – Part 2
63 Demo of complete choreography saga pattern
Orchestration Saga pattern
64 Introduction to Orchestration Saga Pattern
65 Implementing Orchestration saga pattern – Part 1
66 Implementing Orchestration saga pattern – Part 2
67 Implementing Orchestration saga pattern – Part 3
68 Implementing Orchestration saga pattern – Part 4
69 Implementing compensation transactions
70 Demo of Orchestration Saga Pattern
71 Demo of Subscription queries – Part 1
72 Demo of Subscription queries – Part 2
Snapshots in Event sourcing pattern
73 What happens in ES when a new event being stored
74 Demo of events replay, when a new Event being stored
75 Snapshots in Event sourcing pattern – Theory
76 Demo of Snapshots in Event sourcing
Thank You & Congratulations
77 Thank You & Congratulations
Resolve the captcha to access the links!