Gradle exclude java class from lib replaced by own class to avoid duplicate

Gradle Exclude Java Class from Lib Replaced by Own Class to Avoid Duplicate

Understanding the Problem

In Java projects, using external libraries is common practice. However, it’s possible that a library you include contains a class that conflicts with a class you’ve written for your project. This leads to a “duplicate class” error during compilation. This article explores how to resolve this issue using Gradle.

Solution: Excluding Classes Using Gradle Dependencies

Gradle offers several options for excluding specific classes or packages from external libraries:

1. Using Exclusion in Dependencies

The most direct approach is to exclude specific dependencies within your build.gradle file. Here’s how:

Example:

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web:2.7.8")
    implementation("com.example:my-custom-lib:1.0.0") {
        exclude group: "org.springframework.boot", module: "spring-boot-starter-tomcat"
    }
}

In this example, we’re excluding the spring-boot-starter-tomcat dependency from my-custom-lib. This way, your custom class won’t clash with the one from Spring Boot.

2. Using the Exclude Plugin

Gradle provides an exclude plugin for finer-grained control over exclusions. It allows you to exclude specific classes, packages, or even entire jars from your project.

Example:

plugins {
    id 'java'
    id 'org.gradle.test-retry' version '1.3.3'
}

dependencies {
    implementation("com.example:my-lib:1.0.0")
    implementation("com.example:my-another-lib:1.0.0")
}

configurations.all {
    exclude group: 'com.google.guava', module: 'guava'
}

This example excludes Guava library completely from all your configurations.

3. Using the Exclude Transform

For more complex exclusion scenarios, Gradle offers a transform option. You can create a custom transformation task that manipulates the bytecode of the library before it’s used in your project.

Example:

task replaceClass(type: ReplaceTransform) {
    from('lib/my-lib-1.0.0.jar')
    to 'lib/my-lib-replaced.jar'
    exclude 'com/example/MyClass.class'
}

In this example, we replace the entire class from the library with the new version of the class we want to use.

Choosing the Right Approach

Best Practices

• Always try to use the simplest approach first.
• If you’re excluding a large number of classes, consider using the Exclude Plugin.
• For complex scenarios, use the Exclude Transform.
• Document your exclusion logic clearly in your build.gradle file.

Conclusion

By using Gradle’s dependency management features, you can effectively prevent duplicate class conflicts and ensure a smooth compilation process for your Java project. Choose the appropriate exclusion method based on your project’s needs and strive for clarity and maintainability in your Gradle configuration.