Switch to Gradle: Installation, Wrapper, and Dependency Management Guide

Many Java developers use Maven, but its XML configuration can become cumbersome, especially with many dependencies, custom logic, or newer Java versions. Gradle offers a modern alternative that addresses these pain points.

1. Install Gradle

The traditional method is to download the binary package from the Gradle website, unzip it, and add it to the system PATH. However, because Gradle releases new versions frequently, using a package manager is often more convenient. Linux users can install via their distro's package manager, while Windows users are encouraged to use the Scoop package manager, which handles environment variables automatically.

For those who prefer not to install anything, Gradle provides the Gradle Wrapper , a script that automatically downloads and runs a specific Gradle version if it is not already present. Maven also has a wrapper now.

Recent improvements, such as a CDN for the wrapper in China, make Gradle downloads fast, making it an ideal time to start learning Gradle.

2. Use Gradle Wrapper

When creating a Gradle project in IntelliJ IDEA, the IDE automatically uses the Gradle Wrapper, so no local Gradle installation is required. The project structure mirrors Maven's layout, with a gradle folder and gradlew scripts representing the wrapper, and .gradle files serving as Gradle's configuration (equivalent to Maven's pom.xml).

The wrapper allows teams to specify the Gradle version, ensuring consistency across developers. IDEA typically downloads the all distribution, which includes source code for better script support.

3. Dependency Management

Gradle's dependency syntax is concise compared to Maven's verbose XML. A single line can declare a dependency:

dependencies {
    testImplementation 'junit:junit:4.13'
    implementation 'com.google.code.gson:gson:2.8.6'
}

JetBrains' Package Search website is recommended for finding Maven and Gradle artifacts quickly.

Gradle offers finer-grained scopes than Maven:

implementation : available at compile and runtime, but not exposed to consumers.

api : similar to implementation but exposed to consumers.

compileOnly / runtimeOnly : visible only at compile time or runtime respectively.

testImplementation : visible during test compilation and execution.

testCompileOnly / testRuntimeOnly : test‑only equivalents of compileOnly/runtimeOnly.

These scopes provide more precise control over dependency exposure.

4. Tasks and Plugins

Gradle build files are Groovy scripts, allowing programmatic definition of custom tasks. For example, a task can check the size of a generated JAR with just a few lines of code, whereas Maven would require a dedicated plugin.

Gradle's plugin ecosystem is extensive. The gretty plugin, originally community‑maintained and now official, enables running web projects on Tomcat or Jetty with superior functionality compared to similar Maven plugins.

Most common tasks (e.g., build, test) are built‑in and can be inspected directly in IDEA.

5. Configuring Mirrors

Maven's central repository can be slow in China, so developers configure domestic mirrors. Gradle is fully compatible with Maven repositories; adding mirror URLs to an init.gradle script speeds up dependency resolution.

allprojects {
    repositories {
        maven { url "https://maven.aliyun.com/repository/public" }
        maven { url "https://maven.aliyun.com/repository/jcenter" }
        maven { url "https://maven.aliyun.com/repository/spring" }
        maven { url "https://maven.aliyun.com/repository/spring-plugin" }
        maven { url "https://maven.aliyun.com/repository/gradle-plugin" }
        maven { url "https://maven.aliyun.com/repository/google" }
        maven { url "https://maven.aliyun.com/repository/grails-core" }
        maven { url "https://maven.aliyun.com/repository/apache-snapshots" }
    }
}

The Gradle Wrapper stores downloaded distributions under ~/.gradle/wrapper/dists, while cached artifacts reside in ~/.gradle/caches/modules-2/files-2.1, a layout similar to Maven but not directly interchangeable.

If a proxy is required, setting it globally in gradle.properties is recommended.

org.gradle.jvmargs=-Xmx4g -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
systemProp.http.proxyHost=127.0.0.1
systemProp.http.proxyPort=10800
systemProp.https.proxyHost=127.0.0.1
systemProp.https.proxyPort=10800
systemProp.file.encoding=UTF-8
org.gradle.warning.mode=all

6. Why Use Gradle?

Gradle outperforms Maven in several areas:

Speed : Build cache and daemon processes make compilation several times faster, especially for large projects.

Flexibility : Build scripts are Groovy code, allowing complex logic without external scripts.

Conciseness : Equivalent functionality requires far fewer lines than Maven's XML.

These advantages have led many projects, including Spring and Android, to adopt Gradle, making it essential knowledge for modern Java development.