This week we’ve published IntelliJ IDEA 2017.1.2, an update to its current stable release version, and now it’s time to move forward—so say hello to IntelliJ IDEA 2017.1.3 EAP.
In it you will find Kotlin plugin 1.1.2 along with updates to the built-in JRE, among which is better font rendering on Fedora core 25 (Wayland), and an up-to-date macOS binaries signature certificate.
Get it via Help | Check for Updates | Download and install, or let the Toolbox App do it for you!
UPDATE: If you download Windows “.zip” bundle, Kaspersky and some other antiviruses may flag “jre32\bin\unpack200.exe” as a virus. We’re investigating this issue. The workaround is to use “.exe” bundle and not to choose 32-bit JRE.
We’re drawing closer to the release of Java 9, so expect to see more and more Java 9 news as we get nearer to July. We should start to hear more too about what’s coming after Java 9, so now we have a dedicated section just for Java Future news. As usual, we’ve got a good selection of general Java tips, tricks and news, and this month’s design section is very specifically aimed at Java/OO developers. To finish up, we’ve introduced a new Events section, so if we’re in your neighbourhood you can drop in and see us.
If you haven’t updated to IntelliJ IDEA 2017.1 yet (still waiting for stability fixes), we invite you to give a try to the freshly-baked IntelliJ IDEA 2017.1.1 EAP. This build brings some important bug-fixes and improvements.
These two bugs have been fixed:
Fonts were poorly rendered on Linux
The Save All action wasn’t working
There are also a couple of new features in the update:
Better completion for package.json fields
Support for function-based indices in Oracle and Postgres
In other news, the Go plugin now offers a channel for nightly builds. To receive nightly versions of the plugin, register “https://plugins.jetbrains.com/plugins/nightly/9568” as a Repository URL in Settings | Plugins | Browse repositories | Manage repositories.
In the last post we talked about Spring Data improvements, but it doesn’t stop there. IntelliJ IDEA 2017.1, released last week, has enhanced support for testing using the Spring framework.
Gutter Icons and Navigation
You’ll see that where you use the standard test annotations, you have gutter icons to help you to navigate around the code, the same as you’d usually expect from Spring annotations. For example, you can see and navigate to the relevant application contexts, and navigate to the declarations of autowired beans.
IntelliJ IDEA 2017.1 is available for download! In addition to many important bug fixes, this massive update brings lots of improvements to supported languages, frameworks, and built-in tools.
Java 9: The latest builds of JDK 9are fully supported, with assisted project import and coding assistance for editing module declarations. Built-in inspections validate module declarations and provide quick-fixes for adjusting project dependencies. Learn more…
Java 8: Quick-fixes that help migrate for loops to Stream API calls have been improved and now support more sophisticated scenarios. We’ve also added a quick-fix that turns Stream API calls back into for loops, which is handy for debugging or exploring code.
Async-aware debugger: Async stacktraces is a new feature that substitutes parts of a stack trace related to asynchronous code execution with data captured from where that code is invoked. This helps you focus on what you’re debugging. An improved Smart Step Into also supports asynchronous code and lambda expressions running on other threads.
Better VCS: The Log panel for Git and Mercurial has new display options, the Diff dialog gets an option to Ignore imports and formatting, and File History for Git is now faster. We’ve also added Favorite Branches and Speed Search to the Branches popup for Git.
Search: The Find in Path dialog, which previously had added a Preview tab, has been reworked from the ground up and now shows instant results in the first place. What is more important, now you can open any selected result in the Editor simply by pressing Enter.
Spring: Spring Testing has been updated to support Spring Boot 1.4.3, and the upcoming Spring 5.0. Spring Data tools are updated to version 2.0 (including MongoDB, Redis, Solr,KeyValue, Gemfire, Apache Cassandra, REST, Neo4j, Couchbase, and Elasticsearch). There’s also a new Data tab in the Spring tool window which brings better repository navigation.
Gradle: Support for Composite Builds is much improved with the detection of includeBuild in Gradle settings and automatic project configuration.
Scala: Scala plugin improvements include a simpler Project Wizard, better SBT support, additional Akka-specific coding assistance, and the new Worksheet REPL mode.
Database tools: IntelliJ IDEA now allows you to transfer table schemas and data between any two databases (yes, even from MySQL to Microsoft SQL Server and back).
Emoji: The editor now supports Unicode emoji characters (handy for writing comments).
Android Studio 2.2.2: This update includes all changes from Android Studio 2.2.2.
Docker: The Docker plugin now supports Docker for Mac and works via “unix://”.
Windows: The 64-bit installer for Windows lets you give IntelliJ IDEA more RAM.
For more details about IntelliJ IDEA 2017.1, check out the What’s New page.
Your feedback is very much appreciated here in the comments, as always. For bug reports, please use our issue tracker.
P.S. Don’t forget to install Toolbox App – it’s really great at managing your IDE installations and projects. It helps you always be up-to-date with the latest releases, and safely roll back to stable versions if anything goes awry.
The upcoming IntelliJ IDEA 2017.1 includes numerous features to help Spring developers. In this post, we’re going to look specifically at the feature for Spring Data. Support for Spring Data has been updated to include support for features in release train Kay.
One of the new features in IntelliJ IDEA 2017.1 is full support for Gradle Composite Builds. We were fortunate to have Stefan Oehme from Gradle presenting a webinar, showing what composite builds are, how they work and why you might want to use them. In the second part of the webinar, I (Trisha Gee) cover the support for Gradle composite builds in IntelliJ IDEA 2017.1. Take a look at the end of this post for the full video and list of points covered with links to each section.
Imagine you have a project set up to be dependent upon some libraries
You may have access to the source code for this library, and even be able to make changes and commit them, but this traditionally required you to use a different IntelliJ IDEA project to make the changes, then build it and somehow deploy the updated library. But now with Gradle’s Composite Builds, you can easily update and test the library code. All you need to do is to change settings.gradle to include the location of the build for the library code.
Now Gradle is using composite builds, i.e. it can build multiple independent projects together. IntelliJ IDEA recognises this, and as you can see from the screenshot above, it not only updates the Gradle window to reflect the multiple builds, but imports the code for the included build as an additional IntelliJ IDEA module.
Stefan talked about the use cases that really benefit from using Gradle’s composite builds. Composite build support in IntelliJ IDEA means you can work very naturally with code from other libraries, modules or plugins you may be dependent upon. You can make changes to the library code, and even commit these changes to the library’s own repository.
If your projects are already using composite builds, IntelliJ IDEA has full support for importing, building and running these projects. The behaviour inside the IDE is what you would expect, you get the included Gradle builds imported as IntelliJ IDEA modules.
Another use case for composite builds is to bundle together projects, possibly from different repositories, that are effectively separate modules that work together. This use case may be particularly useful if your team is moving from a single repo “monolith” type of application to something that’s made up of independent modules or services. Gradle lets you include the builds for all the different modules (see the settings.gradle in this sample code for an example) into a composite build, and IntelliJ IDEA will find all those Gradle projects and treat them as IntelliJ IDEA modules.
The final example shown in the webinar is how valuable composite builds can be for Gradle plugin developers. Whether you’re developing a plugin and have an example project that uses the plugin to test it, or whether you’re working on an application that uses a plugin that you may want to experiment with, you can create a project from the “consumer” of the plugin (like in this sample code) and see the plugin code also imported as an IntelliJ IDEA module.
In summary, you’ll see that if you’re using composite builds with Gradle, IntelliJ IDEA will figure out the right project and module structure for you to be able to work naturally with the builds you’ve included, with the ability to see the code for the included projects, navigate to it, use refactoring and everything else works as if you were working with an ordinary IntelliJ IDEA module.