How does Gradle manage dependencies? What are the dependency configuration types?

Gradle's dependency management system is one of its core features, providing powerful and flexible dependency management capabilities. Here's a detailed explanation of Gradle dependency management:

Dependency Declaration

Basic Syntax

groovy
dependencies {
    // Format: group:name:version
    implementation 'org.springframework.boot:spring-boot-starter-web:3.0.0'
    
    // Using map syntax
    implementation group: 'org.springframework.boot', 
                   name: 'spring-boot-starter-web', 
                   version: '3.0.0'
}

Dependency Configuration Types

Compile-time Dependencies

groovy
dependencies {
    // implementation: Required for compilation and runtime, but not exposed to consumers
    implementation 'org.apache.commons:commons-lang3:3.12.0'
    
    // compileOnly: Required for compilation but not runtime (e.g., Lombok)
    compileOnly 'org.projectlombok:lombok:1.18.24'
    
    // annotationProcessor: Annotation processors
    annotationProcessor 'org.projectlombok:lombok:1.18.24'
}

Runtime Dependencies

groovy
dependencies {
    // runtimeOnly: Required at runtime but not compilation
    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
}

Test Dependencies

groovy
dependencies {
    // testImplementation: Required for test compilation and runtime
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.0'
    
    // testCompileOnly: Required for test compilation
    testCompileOnly 'org.projectlombok:lombok:1.18.24'
    
    // testRuntimeOnly: Required for test runtime
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
}

Transitive Dependencies

groovy
dependencies {
    // api: Required for compilation and runtime, and exposed to consumers
    api 'org.apache.commons:commons-math3:3.6.1'
    
    // compileOnlyApi: Required for compilation, not runtime, but exposed to consumers
    compileOnlyApi 'org.apache.commons:commons-text:1.10.0'
}

Repository Configuration

Common Repositories

groovy
repositories {
    // Maven Central
    mavenCentral()
    
    // Google repository (common for Android development)
    google()
    
    // Gradle Plugin Portal
    gradlePluginPortal()
    
    // Custom Maven repository
    maven {
        url 'https://maven.aliyun.com/repository/public'
        name 'Aliyun Public'
    }
    
    // Local Maven repository
    mavenLocal()
    
    // Ivy repository
    ivy {
        url 'https://example.com/ivy-repo'
        layout 'pattern'
    }
}

Repository Authentication

groovy
repositories {
    maven {
        url 'https://example.com/private-repo'
        credentials {
            username = 'admin'
            password = 'password'
        }
    }
}

Dependency Version Management

Dynamic Versions

groovy
dependencies {
    // Latest version (not recommended for production)
    implementation 'org.springframework.boot:spring-boot-starter-web:+'
    
    // Latest release version
    implementation 'org.springframework.boot:spring-boot-starter-web:latest.release'
    
    // Latest integration version
    implementation 'org.springframework.boot:spring-boot-starter-web:latest.integration'
    
    // Version range
    implementation 'org.apache.commons:commons-lang3:[3.10,4.0)'
    implementation 'org.apache.commons:commons-lang3:3.+'
}

Using Version Catalog (Recommended)

groovy
// Define in gradle/libs.versions.toml
[versions]
spring-boot = "3.0.0"
commons-lang3 = "3.12.0"

[libraries]
spring-boot-web = { module = "org.springframework.boot:spring-boot-starter-web", version.ref = "spring-boot" }
commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "commons-lang3" }

// Use in build.gradle
dependencies {
    implementation libs.spring.boot.web
    implementation libs.commons.lang3
}

Using ext Properties

groovy
ext {
    springBootVersion = '3.0.0'
    commonsLang3Version = '3.12.0'
}

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-web:${springBootVersion}"
    implementation "org.apache.commons:commons-lang3:${commonsLang3Version}"
}

Dependency Exclusion

Exclude Specific Dependency

groovy
dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web:3.0.0') {
        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
    }
}

Global Exclusion

groovy
configurations {
    all {
        exclude group: 'org.slf4j', module: 'slf4j-log4j12'
    }
}

Dependency Resolution Strategy

Force Specific Version

groovy
configurations.all {
    resolutionStrategy {
        force 'org.apache.commons:commons-lang3:3.12.0'
    }
}

Conflict Resolution

groovy
configurations.all {
    resolutionStrategy {
        // Fail on conflict
        failOnVersionConflict()
        
        // Use latest version
        failOnVersionConflict()
        
        // Use specific version
        force 'org.apache.commons:commons-lang3:3.12.0'
    }
}

Transitive Dependency Management

View Dependency Tree

bash
# View all dependencies
./gradlew dependencies

# View dependencies for specific configuration
./gradlew dependencies --configuration implementation

# View dependencies for specific task
./gradlew :app:dependencies

Stop Transitive Dependencies

groovy
dependencies {
    implementation('com.example:library:1.0.0') {
        transitive = false
    }
}

BOM (Bill of Materials) Management

Import BOM

groovy
dependencies {
    // Import Spring Boot BOM
    implementation platform('org.springframework.boot:spring-boot-dependencies:3.0.0')
    
    // No version needed after import
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

Custom BOM

groovy
// Create platform module
dependencies {
    api platform('com.example:bom:1.0.0')
}

Best Practices

1. Use version catalog: Manage dependency versions uniformly to avoid version conflicts
2. Avoid dynamic versions: Use fixed versions in production environments
3. Choose dependency configurations appropriately: Select implementation, api, etc. based on actual needs
4. Update dependencies regularly: Use ./gradlew dependencyUpdates to check for updates
5. Use BOM: Use BOM to manage versions uniformly for multiple related dependencies
6. Exclude unnecessary dependencies: Reduce dependency conflicts and security risks
7. Use dependency analysis tools: Such as Gradle's dependencyInsight task