Gradle Repositories

External

• https://docs.gradle.org/current/userguide/declaring_repositories.html

Internal

• Gradle Concepts

Overview

A repository is an external source of dependencies, a destination for the artifacts of a project, or both. More formally, a repository is a hosting location for a set of modules, each of which may provide releases identified by the module version. The repository can be based on a product such as Nexus or Artifactory, or it can be a directory on a filesystem. Repositories for a project are usually declared and configured in the repositories{...} script block of the build.gradle associated with the project. At configuration phase, the repositories{...} script block passes the configuration closure specified in the file to its delegate object, which is a RepositoryHandler instance.

Note that a parent's repositories are not automatically made available to the children project in a multi-project build. A repository must be specifically configured on the project or sub-project is we need the project to access artifacts from that repository.

Repository Handler

https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.dsl.RepositoryHandler.html

All repositories associated with a project are maintained within a repository handler, which allows repositories to be defined and queried. The repository handler is one of the project's containers.

Repository Types

Gradle can resolve dependencies repositories based on Maven, Ivy or flat directory formats. More: https://docs.gradle.org/current/userguide/repository_types.html.

Custom Maven Repository

repositories {
    maven {
        // Look for POMs and artifacts here:
        url "http://example.com/maven2"
        // Optionally, if not found at the above location, look for artifacts here:
        artifactUrls "http://example.com/location"
        artifactUrls "http://example.com/location2"
        credentials {
            username "someuser"
            password "somepassword"
        }
    }
}

Pre-Defined Repositories

Some well known repositories are represented in the DSL by RepositoryHandler methods.

Maven Central

repositories {
    mavenCentral()
}

Local Maven repository

Using a local Maven repository makes sense for teams that publish to the local Maven repository with one project and consume the artifacts by Gradle in another project. Note that Gradle has its own dependency cache. A build does not need to declare the local Maven repository even if you resolve dependencies from a Maven remote repository. Gradle uses the same logic as Maven to identify the location of the local Maven repository.

repositories {
    mavenLocal()
}

Repository Authentication

https://docs.gradle.org/current/userguide/repository_types.html#sub:authentication_schemes

repositories {
    maven {
        url 'https://repo.mycompany.com/maven2'
        credentials {
            username "someuser"
            password "somepassword"
        }
    }
}

Repository Preemptive Authentication

https://docs.gradle.org/current/userguide/repository_types.html#sub:preemptive_authentication

repositories {
    maven {
        url 'https://example.com/maven2'
        credentials {
            username "someuser"
            password "somepassword"
        }
        authentication {
            basic(BasicAuthentication)
        }
    }
}

Credential Externalization

Use properties instead of credentials in clear in build.gradle, and then initialize those properties into a local file, such as ~/.gradle/gradle.properties.

build.gradle:

repositories {
    maven {
        url 'https://example.com/maven2'
        credentials {
            username mavenUser
            password mavenPassword
        }
    }
}

~/.gradle/gradle.properties:

mavenUser=someuser
mavenPassword=somepassword