Creating Multi-Release JAR Files in IntelliJ IDEA

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:

Continue reading

Posted in Tips & Tricks | Tagged , | 1 Comment

IntelliJ IDEA 2017.3: VCS enhancements and more

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.

Version Control

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.

showchangestoparent Continue reading

Posted in EAP Releases, New Features | Tagged , | 6 Comments

What’s New in IntelliJ IDEA 2017.3 EAP for Java EE 8

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.

asyncevents2 Continue reading

Posted in EAP Releases, New Features | Tagged , , | Leave a comment

End of support for Visual SourceSafe and ClearCase

As we announced some time ago, we are discontinuing support for ClearCase and Visual SourceSafe as of the 2017.3 release.

This implies several things:

  • Visual SourceSafe Integration plugin has being unbundled for some time already and starting from the latest EAP, ClearCase plugin is also removed from the standard package.
  • Since we do not plan any further development of the plugins, we will close all YouTrack reports for these plugins as of the 2017.3 release.
  • Plugins are now compatible with the Community Edition and are published in the JetBrains plugin repository:

https://plugins.jetbrains.com/plugin/7707-visual-sourcesafe-integration

https://plugins.jetbrains.com/plugin/10095-clearcase-integration

We will maintain compatibility of the plugins with future versions of IntelliJ Platform.

  • We are publishing the source code for both plugins on GitHub to allow users to customize them based on their needs:

https://github.com/JetBrains/clearcase

https://github.com/JetBrains/vss

Posted in Beta Releases, EAP Releases | Tagged | Leave a comment

IntelliJ IDEA 2017.3 EAP brings improvements for unloaded modules

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:Screen Shot 2017-10-12 at 17.19.57

Continue reading

Posted in EAP Releases, New Features | Tagged , , | Leave a comment

Reactive Spring

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’d like to learn more about Spring 5 and reactive programming, make sure to check out these resources:

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.

If you are interested in getting Coroutine support in Spring, check out the corresponding request, share your feedback there or simply vote for it.

That’s it for now. Enjoy watching the webinar recording, play with the demo sources, and happy developing!

Posted in Webinars | Tagged | Leave a comment

IntelliJ IDEA 2017.3 EAP: Configurable command line shortener and more

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.

Screen Shot 2017-10-09 at 08.58.33

Continue reading

Posted in EAP Releases, New Features | Tagged , , | 5 Comments

Real World Java 9

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).

Continue reading

Posted in Webinars | Tagged , | Leave a comment

Java Annotated Monthly – October 2017

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…

JavaAnnotatedMonthly@2x

Continue reading

Posted in News & Events | Tagged , | Leave a comment

IntelliJ IDEA 2017.3 EAP: Grouping modules according to their qualified names and more

Great news! The fresh IntelliJ IDEA 2017.3 EAP build is out! In this EAP build you will find notable features and very important bugfixes.

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.

Continue reading

Posted in EAP Releases | Tagged , , , | Leave a comment