Mastering Patterns in Event-Driven Architecture
Achieving better responsiveness and scalability in your systems
Well-built event-driven architectures leverage asynchronous messaging and event processing to decouple services and maximize your system’s responsiveness, performance, scalability, and elasticity. Unfortunately, with all this power comes a fair amount of complexity. Building an event-driven architecture is hard—really hard.
Expert software architect Mark Richards takes you through the advanced design patterns that will help you achieve better responsiveness and scalability in your event-driven architecture. Join in to get hands-on with the tools and techniques to tackle the hard parts of event-based processing. Through pattern walk-throughs and live code demos, you’ll learn how each event-driven pattern works, the problems it solves, and its trade-offs, ensuring that you can make the best choices for your system.
What you'll learn-and how you can apply it
By the end of this live online course, you’ll understand:
- How to guarantee that no messages are lost when using events and messaging
- How to provide elasticity and scalability without impacting responsiveness
- How to handle asynchronous error conditions
- How to guarantee message processing order with highly parallel processes
- How to significantly increase overall message throughput when that throughput exceeds broker limits
- How to properly deal with message priority and contextual messages
- When to apply these patterns and when not to
And you’ll be able to:
- Increase the scalability of your applications
- Increase the responsiveness and overall performance of your applications
- Increase the elasticity of your applications
This training course is for you because...
- You're an architect or developer designing or building event-driven systems.
- You want to better understand the complexities of event-driven systems.
- You want to apply various patterns of event-driven architecture to better deal with error handling, scalability, elasticity, responsiveness, and other event-driven challenges.
- A working knowledge of messaging and event-based systems
- A basic understanding of how messaging (queues and topics) works
- Explore relevant sections of Enterprise Messaging Techniques (learning path)
- Watch relevant sections of Enterprise Messaging: JMS 1.1 and JMS 2.0 Fundamentals (video, 5h 29m)
- Watch relevant sections of Enterprise Messaging with JMS: Advanced Topics (video, 3h 52m)
- Read relevant chapters of Java Message Service, second edition (book)
About your instructor
Mark Richards is an experienced, hands-on software architect involved in the architecture, design, and implementation of microservices architectures, service-oriented architectures, and distributed systems in a variety of technologies. He has been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. Mark served as the president of the New England Java Users Group from 1999 through 2003. He is the author of numerous technical books and videos, including the Software Architecture Fundamentals Video Series (O’Reilly video), Enterprise Messaging (O’Reilly video), Java Message Service, 2nd Edition (O’Reilly), and several books and videos on Microservices (O’Reilly). Mark is also a conference speaker and trainer and has spoken at hundreds of conferences and user groups around the world on a variety of enterprise-related technical topics.
The timeframes are only estimates and may vary according to how the class is progressing
Introduction to event-driven patterns (10 minutes)
Event forwarding pattern (20 minutes)
Supervisor-consumer pattern (30 minutes)
Break (10 minutes)
Workflow event pattern (15 minutes)
Producer control flow pattern (20 minutes)
Ambulance pattern (15 minutes)
Break (10 minutes)
Watch notification pattern (15 minutes)
Multibroker pattern (10 minutes)
Contextual queue pattern (10 minutes)
Thread delegate pattern (15 minutes)