Gradle Dependency Management

Dependency management is a core feature that simplifies including external libraries or modules in your project. It automates downloading required files, resolving conflicts, and making them available during compilation or runtime.

What is a Gradle Dependency?

A Gradle dependency refers to an external library, framework, or module that your project relies on to function. For example, you might need a testing library like JUnit or a utility like Google Guava. Gradle handles fetching these dependencies from remote repositories and integrating them into your project.

Types of Dependencies

Gradle dependency types are as follows:

Type	Description
Module	External open-source libraries (e.g., Guava, Spring).
Other Project	Modular codebases split into subprojects (e.g., app, core, data).
File	Proprietary JARs, legacy libraries, or local testing.

Implementation Dependencies

Declared using implementation. These are required for compiling and running the main code. They are included in the runtime but not exposed to other modules.

Compile-Only Dependencies

Declared using compileOnly. These are needed only during compilation (e.g., annotations) and not included in the final output.

Runtime Dependencies

Declared using runtimeOnly. These are not needed for compilation but required during runtime (e.g., database drivers).

Test Dependencies

Declared using testImplementation. These are used only for testing (e.g., JUnit, Mockito) and not included in the production build.

Declaring Dependencies

Dependencies are defined in the build.gradle file using the format:
dependencies {
implementation 'group:name:version'
}
Example: implementation 'org.junit.jupiter:junit-jupiter:5.9.0'

Repositories

Gradle fetches dependencies from repositories like Maven Central or Google’s Maven Repository. These are declared in the build.gradle file:

For example:

repositories {
mavenCentral()
}