One of the interesting features of Java 9 is support for Multi-Release JAR Files. What does this mean? In the past, library developers had three options when it came to supporting newer versions of Java:
The IntelliJ IDEA 2017.3 EAP is available! Before we take a look at the exciting new features the latest IntelliJ IDEA 2017.3 EAP build has to offer, let’s talk about the VCS features we briefly announced last week.
If you use Git or Mercurial for version control, you can already view all commits to all the branches in the Log view. Starting with this EAP, the IDE shows the files changed by merge commits even if they only differ from one parent. Previously only the files that had merged conflicts were displayed.
The long-awaited Java EE 8 is here, and it adds many new capabilities to the platform: Multiple CDI enhancements, including support for asynchronous events, HTTP/2 support in Servlet 4.0, and more. The IntelliJ IDEA 2017.3 EAP build expands support for Java EE 8 key features. We recently briefly announced these features, and now it’s time to provide more details on the improvements we’ve made in this area.
Support for async events
Starting with CDI 2.0, events can be fired asynchronously. IntelliJ IDEA 2017.3 supports Asynchronous CDI Events, and allows you to easily navigate between where the event was fired and where this event was received.
The latest IntelliJ IDEA 2017.3 EAP build brings lots of new features, and now it’s time to take a look at the improvements for unloaded modules.
In IntelliJ IDEA 2017.2 we announced an experimental feature called Load/Unload Modules. This feature allows you to unload unnecessary temporary modules from your project. The Load/Unload Modules feature is especially useful for managing modules in large projects.
Until now, however, if you updated via a VCS, all newly added modules were marked as loaded by default. This was not very convenient and in some cases could even lead to compilation failures.
As an example, let’s look at a project with the following dependencies:
As you might already know, Spring 5 went GA a couple of weeks ago. To celebrate this, last week we held an incredible webinar by Josh Long on Reactive Spring. If you have followed the news about the release, you probably already know that among other things (such as JDK 9, Java EE 8, and Kotlin support), Spring 5 can integrate with Spring Reactor to support reactive programming.
In this webinar, Josh not only introduced reactive programming and what it’s about, but also a gave a hands-on live coding demo on how to use Reactive Spring to build message-driven, elastic, resilient and responsive services–in both Java and Kotlin. The sources of the code shown in his demo are available on GitHub.
Don’t worry if you missed the webinar as we have now made the recording available here. Enjoy watching!
If you don’t plan on watching the whole one-hour video, here’s a list of links to jump to the part of the video which is most relevant to you.
If you liked how Kotlin works with Spring 5 or are just getting started with Kotlin, check out Kotlin’s website where you’ll find tons of tutorials and examples.
Because the biggest part of Josh’s session was in Kotlin, there was a question from the audience on whether Spring is going to support Coroutines, the experimental feature introduced in Kotlin 1.1 for making multi-threaded and reactive programming easier. One of the attendees shared a link which explains how Coroutines can empower Spring developers to write more readable code for reactive services.
We are approaching the release of IntelliJ IDEA 2017.3 and are proud to give you a new EAP build! This build comes with awesome new features, and we hope these improvements will help you become even more productive.
Configurable command line shortener
When the classpath gets too long, or you have many VM arguments, the program cannot be launched. The reason is that most operating systems have a command line length limitation. In such cases IntelliJ IDEA will try to shorten the classpath.
There are several approaches to shorten the classpath. Initially, IntelliJ IDEA tried to write the long classpath into the text file (which means an intermediate classloader to the application). But unfortunately, this didn’t work for some frameworks, e.g. JMock. Then, IntelliJ IDEA tried to use a more or less standard way, which was to pack the long classpath into the classpath.jar. Unfortunately, that didn’t work either, for some other frameworks.
And, sadly, there is no way to predict which kind of shortening would work for the user application. So the user is left having to make this decision. For Application, JUnit and TestNG configurations, 2017.3 EAP provides a way to configure the shortener.
Starting with this EAP, there is no more need to edit the settings of your IDE through the XML files.
IntelliJ IDEA 2017.3 EAP build provides a convenient way to specify the method to shorten command line, for each configuration.
Last week we hosted a live webinar covering the features of Java 9 that are most interesting to developers. The recording is available here for those who missed it, and we also wanted to take this opportunity to answer all those questions we didn’t have time for during the session. If you read beyond the fold you’ll find the timeline of which features are covered (with links to that section in the video) and answers to all the questions (with links and more detail where relevant).
Java 9 is here! At long last. This month we have lots of Java 9 content, of course, but that’s actually not the only Big News: not only is Java EE 8 also now available, but we can look forward to a new release of Java every six months. So we’re celebrating Java 9, but we’re already anticipating Java 10. It might not even be called Java 10…
Last week Java 9 was released, and it brings the module concept to the Java platform – the project known as Jigsaw. Project Jigsaw aims to make it easier for developers to build and maintain large applications. The new concept encourages you to modularize your application. IntelliJ IDEA 2017.3 provides different features to support Java 9. You can learn more about Java 9 support in IntelliJ IDEA in this blogpost.
And with this new EAP, we expand the support for this with the new method of module organization – grouping modules according to their qualified names.
Up until now the IDE only offered one way to organize modules – module groups. There are several problems with such an approach. First of all, module names should be unique, over all the modules in a project. Also if you want to use the same module in different projects, you need to specify the module group for this module, in each project, because a module groups configuration stored in the project configuration, not *.iml files.