IntelliJ IDEA 2019.2 Help

Gradle projects

IntelliJ IDEA lets you manage Gradle projects. You can link, ignore projects, and synchronize changes in Gradle and IntelliJ IDEA projects. You can also configure a Gradle composite build, Gradle source sets, the build and run actions.

  1. In the Gradle tool window, right-click a linked project.

  2. From the context menu, select Open Gradle config N/A.

    IntelliJ IDEA navigates to the appropriate Gradle configuration file and the related build.gradle file opens in the editor.

Unlink a linked Gradle project

When you unlink a Gradle project, IntelliJ IDEA removes all relevant modules and content roots, removes the Gradle project from the Gradle tool window and stops its synchronization. It might be helpful if you need to fully remove the previously linked Gradle project from the current IntelliJ IDEA project.

  1. In the Gradle tool window, right-click a linked project.

  2. From the context menu, select Unlink Gradle project (N/A ). Alternatively, you can select the linked project and click icons general remove svg on the tool window's toolbar.

  3. In the Import Gradle Projects popup, clear the checkbox against the modules if you don't want to delete the project from the IntelliJ IDEA Project tool window.

  4. Click OK.

    If you need to link back the project, in the Project tool window, right-click the project's build.gradle file or build.gradle.kts if it is a Kotlin project, and select Import Gradle Project.

Ignore a Gradle project

You can de-activate a Gradle project using the Ignore Gradle Project option. In this case, IntelliJ IDEA keeps the ignored Gradle projects and subprojects in the Gradle tool window, but stops their import (modules, content roots, tasks, and so on) to the project. However, IntelliJ IDEA synchronizes the ignored projects with the current one. It might be helpful if you need to skip an irrelevant subproject such as buildSrc.

  1. In the Gradle tool window, right-click the project that you want to ignore.

  2. From the context menu, select Ignore Gradle Project.

  3. In the window that opens, select projects and modules that you want to de-activate and click OK.

If you want to activate your Gradle projects or modules, select Unignore Gradle Projects from the context menu.

Re-import a linked Gradle project

  1. In the Gradle tool window, right-click a linked project.

  2. From the context menu, select Reimport Gradle project icons actions refresh svg.

    On invoking this action, IntelliJ IDEA parses the project structure in the Gradle tool window.

    IntelliJ IDEA cannot re-import just a part of your project, it re-imports the whole project including modules and dependencies.

    If you configure a dependency through the Project Structure dialog (click the Project Structure button, from the main menu), the dependency will only appear in the IntelliJ IDEA Project tool window, not in the Gradle tool window. Note that the next time you re-import your project, IntelliJ IDEA will remove the added dependency since IntelliJ IDEA considers the Gradle configuration as a single source of truth.

Configure Gradle Composite Build

Before you start configuring your composite build, make sure you have the Gradle version 3.1 or later configured for your project.

You can use the settings.gradle file to include Gradle builds for your Gradle composite build.

  1. Open the settings.gradle file in the editor.

  2. Using the includeBuild command, specify the location of the builds you want to add as dependencies to your project.

You can also use the Gradle tool window to configure the composite build.

  1. Open a Gradle project.

  2. Link other Gradle projects that you want to use for the composite build.

  3. In the Gradle tool window, right-click your main project and from the context menu select Composite Build Configuration.

  4. In the Gradle Project Build Composite dialog, select projects that you want to include in your Gradle composite build.

  5. Re-import your main Gradle project.

    IntelliJ IDEA finds the included Gradle projects and treats them as IntelliJ IDEA modules.

Use Gradle source sets

IntelliJ IDEA lets you use Gradle source sets in resolving Gradle projects. The source set is treated as a module in an IntelliJ IDEA project. You can declare a custom source set and IntelliJ IDEA adds it as a module to the project.

When you create a Gradle project, IntelliJ IDEA automatically creates a main Source Sets directory that contains two source sets - main and test. For compiling the test sources there is a dependency to the main source set.

Gradle tool window: source set

Add a custom source set

  1. Open the gradle.build file in the editor.

  2. Declare a custom source set (In our example, it's api).

    sourceSets { api } dependencies { compile sourceSets.api.output }
    (This source set contains interfaces without implementations. The implementations for the interfaces are in the default main source set.)

  3. Open the Gradle tool window to see that IntelliJ IDEA added the api source set.

    Gradle tool window: api Source Set
    The test source set contains the appropriate dependencies. Note that the default main source set has the compile dependency on the output of the api source set. Gradle will invoke the apiClasses task automatically if you compile the sources in the main source set.
    Gradle tool window: compile dependency

  4. From the main menu, select File | Project Structure N/Ato open the project structure. Notice that all source sets are represented as separate modules that are grouped into a single module.

    Project Structure dialog / Module page
    If you click the test module and select the Dependencies tab, you will see a list of dependencies for the source set.
    Project Structure dialog / Dependencies tab

Use source sets for custom tests

You can add custom tests and run them separately from the main ones using a source set feature.

  1. Declare a source set the same way as you would declare the custom source set. Besides the name of you source set, specify an output directory and a task that will run the declared test. For example, declare an integration test integrationTest.

    sourceSets { integrationTest { java { srcDir 'src/integrationtest/java' } resources { srcDir 'src/integrationtest/resources' } compileClasspath += sourceSets.main.runtimeClasspath } } task integrationTest(type: Test) { description = "Runs Integration Tests" testClassesDirs = sourceSets.integrationTest.output.classesDirs classpath += sourceSets.integrationTest.runtimeClasspath }

  2. In the Gradle tool window, click Tasks | other.

  3. In the list that opens, double-click the integrationTest to run it.

    Gradle tool window: tasks

Add package prefixes in the Gradle project

If you use package prefixes in your Gradle project, specify them in the build.gradle file. That way, everything is saved when you reimport your project.

For more information, see https://github.com/JetBrains/gradle-idea-ext-plugin.

  1. Open the build.gradle file.

  2. Add the following plugin to support package prefixes:

    plugins { id "org.jetbrains.gradle.plugin.idea-ext" version "0.5" }

  3. Add the package prefixes. For example, you have the following set of source sets:

    sourceSets { main.java.srcDirs = [] main.java.srcDirs += "src" main.java.srcDirs += "src/main/java" main.java.srcDirs += "../other-root/src/main/java" }
    Add the package prefixes (in our case it is "org.example") to them with the following code:
    idea { module { settings { packagePrefix["src"] = "org.example" packagePrefix["src/main/java"] = "org.example" packagePrefix["../other-root/src/main/java"] = "org.example" } } }

  4. Reimport your changes or use the auto-import.

Specify IDE-specific settings in the build.gradle file

Using the gradle-idea-ext plugin, you can describe project settings such as project encodings, and the encoding for properties files inside the build.gradle file.

  1. Open the build.gradle file.

  2. Add the following plugin to support the encodings configuration:

    plugins { id "org.jetbrains.gradle.plugin.idea-ext" version "0.5" }

  3. Describe the project encodings with the following code:
    import org.jetbrains.gradle.ext.EncodingConfiguration.BomPolicy idea { project { settings { encodings { encoding = 'windows-1251' bomPolicy = BomPolicy.WITH_NO_BOM properties { encoding = '<System Default>' transparentNativeToAsciiConversion = false } mapping['../sample-gradle-free/module'] = 'windows-1251' mapping['module'] = 'windows-1251' mapping['module2/src/main/java'] = 'windows-1251' } } } }
  4. Reimport your changes or use the auto-import.

Use buildSrc

If you have a large Gradle script that includes several Java, Groovy, or Kotlin classes, you can move such classes to the buildSrc directory and refer to them from your main Gradle script. In this case you ensure the readability of the build.gradle file.

  1. If you don't have and existing buildSrc, add it as a Gradle module to your main project.

    Project tool window: buildSrc module

  2. Open your main build.gradle file in the editor and move the classes you need to the main subdirectory of the buildSrc directory.

    Project tool window: buildSrc

  3. Run your task from your project's build.gradle file.

    gradle main build file

Configure the build and run actions

By default, IntelliJ IDEA uses Gradle for building and running projects.

When you build a project (Build | Build Project), IntelliJ IDEA invokes the corresponding tasks using Gradle. Gradle also executes the Run and Debug actions from the Run menu. HotSwap is also gets triggered and the classes are reloaded during a debugging process.

If you have linked projects, you can configure how to build each linked project.

  1. In the Settings/Preferences dialog N/A, go to Build, Execution, Deployment | Gradle.

  2. On the Gradle settings page, in the Gradle Projects section, select a Gradle project you need.

  3. In the Build and run using list, select the appropriate option and click OK to save the changes.

If you want to use IntelliJ IDEA for building a Gradle project, you need to explicitly specify so.

Delegate a build to IntelliJ IDEA

It might be helpful to use IntelliJ IDEA for building a pure Java or Kotlin project. It could speed up the building process since IntelliJ IDEA supports the incremental build. Yet, keep in mind that the IntelliJ IDEA compiler does not support some parts of the Gradle project build processing and might cause problems in building your project correctly.

  1. Click icons general settings svg in the Gradle tool window. Alternatively, from the main menu select File | Settings/Preferences | Build, Execution, Deployment |Build Tools |Gradle.

  2. On the Gradle page, from the Build and run using list, select Intellij IDEA.

    gradle delegate ide run to gradle
    Note that the Run test using option stays active and you can select how you want to run your tests even if you delegated all build and run actions to IntelliJ IDEA.

  3. Click OK.

Now if you build your Gradle project, it will be built with IntelliJ IDEA.

Last modified: 19 August 2019