Join one of our GOTO experts for a one-, two- or three-day online masterclass that will give you a deep dive into a specific area of tech. Expect to get up close and personal with a seasoned software expert over the course of this paid training session from the comfort of your home.
Who is the Masterclass for?
If you are a software engineer who is building microservices, distributed systems or highly-networked applications and you want to make your system efficient and keep your code clean, then this course for you. You will learn the benefits of reactive programming and Reactive Streams, how to use one of the most popular implementations called Project Reactor and how to build efficient microservices with Reactive Spring.
This Masterclass will cover:
- The Reactive System
- Reactive Programming History and Motivation
- Reactive Streams
- Project Reactor API From A-Z
- Project Reactor In Action
- Improving Resilience with Project Reactor
- Handling Transactions and Distributed Transactions
- Flow Control techniques in Practice
- Microservices with Reactive Spring
- R2dbc in Action
- RSocket in Action
- Building end-to-end Reactive System
Agenda: Part 1
Day 1 will focus on learning the essentials of reactive programming, reactive streams, and project reactor as one of the famous implementations.
We will cover:
- The motivation behind Reactive
- We are going to look at different meanings of the word “reactive” and how reactive programming was evolving over time.
- Introduction to Project Reactor
- A short Story of Project Reactor and the Reactive Types it has.
- Project Reactor Essentials
- At this point I’m covering the API every Project Reactor user should know in order to generate/transform Flux or Mono stream. Also, attendees are working on a set of exercises:
- How to Create Flux and Mono (followed by exercises)
- How to Do essential transformations on a stream of data (followed by exercises)
- Project Reactor Advanced
- How to Deal with Multiple streams at a time (followed by exercises)
- How to Work with Multithreading (followed by exercises)
- How to Control Flow of elements (followed by exercises)
- How to Work with Resilience and handle Errors (followed by exercises)
- How to Work with Contextual Data (followed by exercises)
- How to Test (followed by exercises)
- How to Log, Debug and collect Metrics (followed by exercises)
Key takeaways: Reactive System, Reactive Programming History and Motivation, Reactive Streams, Project Reactor API From A-Z
Agenda: Part 2
Day 2 will focus on getting a proper understanding of how to apply the API of the Project Reactor in order to solve common microservices problems.
We will be:
- Implementing the logic of a part of the orders analytic app. Here the attendee is going to collect data from a few data sources and apply transformations on them.
- Implementing a load balancer which should work in a few balancing modes that everyone will have to implement using Project Reactor.
- Working with Blocking API. In this task, the student will be required to adopt a blocking JPA repository using Project Reactor Scheduler API and operators which affect on which thread processing is happening.
- Working with Backpressure on a sample of data uploading and external service API which has a strict limitation on the number of requests/second and some limitations on how data should be sent. In this example, attendees will have to brainstorm on how to follow all the limitations put by external service and write their implementation as elegant as possible using Project Rector API only.
- Managing distributed transactions or simply talking implementing orchestrated saga pattern using Project Reactor. In this exercise, the student will get an API of an asynchronous Database driver and will have to ensure that the same record went into both databases.
- Working with Reactive Context and in this exercise, we are going to write a Reactive Dependency Injection Mechanism. In this case, we will reference some limitations of Spring WebFlux and session scoped beans and how it could be solved if we store all the session scoped beans in the Reactor Context
Key takeaways: Project Reactor In Action, Improving Resilience with Project Reactor, handling Transactions and Distributed Transactions, Flow Control techniques in Practice
Agenda: Part 3
- Writing Reactive System using Reactive Spring.
- Intro into Reactive Spring and set of reactive technologies it has.
- Reactive Relational Database access - here we are going to cover R2dbc and how to work with it
- Reactor-Netty - the main web framework for Spring WebFlux
- Spring WebFlux and Spring Data R2dbc
- RSocket and Spring Messaging RSocket
- Intro into the microservices system we are going to build.
- Step by step writing of every component of the system using the aforementioned technologies
Key takeaways: Microservices with Reactive Spring, R2dbc in Action, RSocket in Action, Building end-to-end Reactive System
Are there any prerequisites?
Laptop JDK 8+ installed on it IntelliJ IDEA (latest available preferred) Installed EduTools as a plugin or a separate IDE (the version must be 3.1 or higher) - (see https://www.jetbrains.com/help/education/educator-start-guide.html)
Other Online Masterclasses
Designing APIsMike AmundsenMonday Jun 21, 13:30 CET
Core SpringJoris KuipersTuesday Jul 13, 09:00 CET
Advanced Deployment Pipeline TechniquesDave FarleyTuesday Jul 20, 09:00 CET
Reactive ProgrammingOleh DokukaTuesday Sep 14, 09:00 CET
Code as a Crime SceneAdam TornhillWednesday Sep 15, 09:00 CET
Designing MicroservicesSam NewmanWednesday Sep 15, 09:00 CET
Architecture with Agility MasterclassKevlin HenneyPast event
Roy Osherove: The art of Unit Testing in JavaRoy OsherovePast event
Certified Scrum Product OwnerJens ØstergaardPast event
Certified ScrumMasterJens ØstergaardPast event
Architecture with AgilityKevlin HenneyPast event
Code As A Crime Scene: Fix Technical Debt with Behavioral Code AnalysisAdam TornhillPast event