# Dependency Management

version 8.12

Software projects typically depend on other libraries to function. These libraries can either be sourced from other projects in the same build or from external repositories.

Gradle’s dependency management infrastructure provides APIs to declare, resolve, and expose binaries required by and provided by a project.

Understanding dependency management in Gradle is important for structuring projects into components. It is also important when you want to reuse existing libraries, or you need to upgrade those libraries while managing their versions.

Let’s look at a Java project where the code relies on Guava which is a suite of Google Core libraries for Java. The build file of the project includes the following:

build.gradle.kts

    dependencies {
        implementation("com.google.guava:guava:32.1.2-jre")
        api("org.apache.juneau:juneau-marshall:8.2.0")
    }

build.gradle

    dependencies {
        implementation("com.google.guava:guava:32.1.2-jre")
        api("org.apache.juneau:juneau-marshall:8.2.0")
    }

Within the `dependencies` block, there are three things to notice when a dependency is declared:

1. The configuration: `implementation` also known as the scope the dependency is applied to

2. The module ID: `com.google.guava:guava` is made up of a `group` and an artifact `name` which are uniquely identifiable

3. The version: `32.1.2-jre` which is not always required

Dependencies can be local or external. To let Gradle know where to find external dependencies, use the `repositories{}` block in the Build File.

Let’s expand our example:

build.gradle.kts

    repositories {
        google()
        mavenCentral()
    }

    dependencies {
        implementation("com.google.guava:guava:32.1.2-jre")
        api("org.apache.juneau:juneau-marshall:8.2.0")
    }

build.gradle

    repositories {
        google()
        mavenCentral()
    }

    dependencies {
        implementation("com.google.guava:guava:32.1.2-jre")
        api("org.apache.juneau:juneau-marshall:8.2.0")
    }

In this example, Gradle fetches the `guava` and `juneau-marshall` dependencies from the Maven Central and Google repositories.

## 1. The Basics

If you want to understand the basics of dependency management and you are new to Gradle, start here.

## 2. Declaring Dependencies

You can add external libraries to your Java project, such as `Guava`. These libraries are dependencies of your project. They are added using the `dependencies{}` block in your build file.

## 3. Declaring Repositories

You can declare repositories to tell Gradle where to fetch external dependencies. During a build, Gradle locates and downloads the dependencies, a process called dependency resolution.

## 4. Centralizing Dependencies

To keep dependencies and their versions declared in a single, manageable location (i.e., centralized), you can use platforms and version catalogs.

A platform is a set of modules intended to be used together. A version catalog is a centralized list of dependency coordinates that can be referenced in multiple projects.

## 5. Managing Dependencies

Conflicts can arise when the same library is declared multiple times or when different libraries provide the same functionality. This usually leads to failing builds.

You can manage conflicts using resolution rules or dependency locking.

## 6. Understanding Dependency Resolution

In order to influence how Gradle resolves dependencies, it’s important to understand how it works. This section covers variants, attributes, capabilities and dependency caching.

## 7. Controlling Dependency Resolution

Once you have a grasp of how dependency resolution works, you can view, control and influence it. This section covers graph and artifact resolution, as well as artifact transforms.

## 8. Publishing Libraries

If you are considering publishing your library for consumption as a dependency, check out our publishing chapter.