Reactive Programming Made Easy
We’ve got all of the project Reactor adepts and enthusiasts out there covered! Whether you’re a seasoned pro or just taking your first steps in the field, IntelliJ IDEA will make reactive coding a breeze. It simplifies the complexities of Reactive Streams, ensuring a smooth and efficient experience for all skill levels.
This article covers the most significant features and tools, including live templates, a dedicated debug mode, and helpful inspections. The examples provided below are from existing projects, so we won’t discuss adding reactor support at the initial launch.
Get ready to unlock the full potential of reactive programming with IntelliJ IDEA!
In reactive programming, Mono and Flux are two fundamental types of the Publisher interface used to represent reactive streams. They provide powerful operators and methods to change and organize data effectively.
Let’s see what features and tools IntelliJ IDEA provides to conveniently work with these crucial types.
Reactor live templates
Who doesn’t love typing less and coding faster? Reactive live templates will help you do exactly that!
IntelliJ IDEA also offers a feature called postfix code completion for projects that use Reactor. With this feature, you can automatically transform a previously typed expression into a reactive one based on what you’ve written.
When working on projects that have Reactor support, IntelliJ IDEA can automatically wrap an expression with the appropriate Reactor factory, either Flux or Mono.
Here’s how you can effortlessly return Mono from the string with the help of the toMono live template:
Debugging Reactor Streams
IntelliJ IDEA allows you to debug your reactive projects. Prior to starting the process, you’ll need to adjust your configurations. Go to Preferences/Settings | Languages & Frameworks | Reactive Streams. Tick the Enable Reactor Debug mode option and select Hooks.onOperatorDebug().
Now, when the necessary configurations are there, let’s see how our debugger works with reactive projects. The first thing worth noting is that it detects the Flux and Mono types while debugging. You can see them marked with green icons. Once you click on them, you’ll see the results of calculations inside them on the right, in the Variables view.
It’s now possible to evaluate these types. To do so, click the get or collectList link next to the displayed result. The IDE will then instantly compute the reactive stream items.
You can also perform more complex evaluations.
By default, the debugger fetches the first 100 items of Flux. You can configure this number in File | Settings | Languages & Frameworks | Reactive Streams. Each time you trigger a computation, the IDE subscribes to a Publisher value and assumes the operation is safe to retry.
Noteworthy inspections for daily needs
Our helpful inspections are always ready to highlight inconsistencies in your code – everybody can use an extra set of eyes! We’ll demonstrate two of the most helpful inspections that you can benefit from when using Reactive Streams.
Unused Publisher value
To use an operator that produces a new Publisher instance, you must subscribe to the created Publisher via subscribe() or return a value from a method. If you don’t do this, the created reactive stream is never used – in reactive programming terminology, “The value is never used as the Publisher type”. Here is where our first inspection comes in handy by reporting unused Publisher instances.
Blocking call in non-blocking context
You can use code that might cause a delay or pause in a program where it’s not supposed to. IntelliJ IDEA provides the Possibly blocking call in non-blocking context inspection that looks for situations like this.
It is convenient to annotate code blocks with @Blocking and @NonBlocking annotations from the JetBrains annotations collection. This helps IntelliJ IDEA detect blocking calls in non-blocking contexts. To get the annotations, add org.jetbrains:annotations version 22.0.0 or later to your project’s dependencies.
In this article, we’ve demonstrated the most helpful features IntelliJ IDEA has for developers who work with Reactive Streams. We hope that you will use them on a daily basis and enjoy smoother and faster reactive programming. If you have any ideas for other helpful features, let us know in the comments.
Subscribe to Blog updates
Thanks, we've got you!
IntelliJ IDEA 2023.3 EAP Is Open!
The IntelliJ IDEA 2023.3 Early Access Program kicks off today! Read this blog post to explore the new features you can test in the first EAP build.
Import Postman Collections to the HTTP Client
We know that many of you use Postman collections and want to stay in the flow while working with them. This means staying inside IntelliJ IDEA and not switching to a different app. Great news! You can now effortlessly transform Postman collections into .http and use them in the HTTP Client …
Java Annotated Monthly – September 2023
The September edition of Java Annotated Monthly is here! With this month’s release of Java 21 approaching, we're excited to bring you a final sneak peek into its crucial features. But that's not all! This edition is packed with helpful articles about cutting-edge AI technologies, including update…
IntelliJ IDEA 2023.2.1 Is Out!
We’ve just released the first bug-fix update for v2023.2. You can update to this version from inside the IDE, using the Toolbox App, or via snaps, if you’re using Ubuntu. You can also download it directly from our website. Here is the list of the most notable improvements and fixes inclu…