All 15 Build Tools: Maven & Gradle questions
More in Build Tools: Maven & Gradle
How do you resolve a dependency version conflict manually in Maven using exclusions, and when would this be necessary despite the automatic nearest-wins resolution? What is a Maven BOM (Bill of Materials), and how does it help manage consistent dependency versions across a multi-module project or organization? How do you manage different configurations for different environments (development, staging, production) using Maven profiles or Gradle's equivalent mechanisms? How do you configure the Maven Compiler Plugin to target a specific Java language version, and what's the difference between source, target, and release configuration? How does Gradle's incremental build and build cache mechanism achieve significantly faster rebuild times compared to Maven's default behavior? How would you configure a multi-module Maven or Gradle project, and what benefits does modularizing a large codebase this way provide? How would you write a custom Maven plugin or Gradle task to perform project-specific build automation not covered by existing plugins? How would you configure a Maven or Gradle build to produce a reproducible build (bit-for-bit identical output given the same source), and why does this matter for supply chain security? How would you configure a Maven or Gradle build to produce a shaded/fat JAR containing all dependencies bundled into a single executable JAR file?
Advertisement
Back to results for “Performance”
Java › Build Tools: Maven & Gradle

How does Maven's dependency resolution algorithm handle transitive dependency version conflicts, and what is the "nearest definition wins" rule?

Advanced

Answer

When multiple dependencies (directly or transitively) require different versions of the same library, Maven resolves the conflict using "nearest definition wins": the version declared at the shallowest depth in the dependency tree (closest to your project's own pom.xml) takes precedence, with ties broken by declaration order -- this can silently select an unexpected or incompatible version, so Maven provides `mvn dependency:tree` to visualize the actual resolved tree and `<dependencyManagement>` or explicit `<exclusions>` to override the automatic resolution when the default nearest-wins choice is wrong for your project.
<!-- Forcing a specific version regardless of transitive resolution -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.2</version>  <!-- forces this version project-wide -->
        </dependency>
    </dependencies>
</dependencyManagement>

# Diagnose the actual resolved dependency tree
mvn dependency:tree -Dverbose
Real-world example A team debugging a mysterious NoSuchMethodError in production traces it to Maven's nearest-wins rule silently selecting an older, incompatible version of a transitive dependency over the newer version the team actually needed, resolved by explicitly pinning the correct version via dependencyManagement.

Common follow-ups: How does Gradle's dependency resolution strategy (highest version wins by default) differ from Maven's nearest-wins approach?;What's the practical difference between <exclusions> and <dependencyManagement> for resolving a conflict?

Diagnostics & Performance;Class Loading & Bytecode Verification
All 15 Build Tools: Maven & Gradle questions