0Pricing
Groovy & Gradle: JVM Automation and Build Engineering · Leçon

Publication dans des dépôts

Publiez les artefacts de votre projet dans les dépôts Maven Central, Artifactory ou Nexus.

Publication dans des dépôts est une leçon Groovy & Gradle: JVM Automation and Build Engineering gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Groovy & Gradle: JVM Automation and Build Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Welcome to Publishing!

Ever wondered how open-source libraries or internal company tools become available for others to use? It's all about publishing!

In this lesson, you'll learn how to use Gradle to publish your project's compiled artifacts (like JARs) to central repositories. This makes them easily consumable as dependencies by other projects.

Artifacts & Repositories

Let's clarify some key terms:

  • An artifact is a deployable output of your project, typically a compiled JAR, WAR, or AAR file. It's the 'product' you want to share.
  • A repository is a storage location for these artifacts. Think of it as a digital library where artifacts are stored and retrieved. Examples include Maven Central, JCenter, Artifactory, or Nexus.

They are crucial for managing project dependencies.

The Maven Publish Plugin

Gradle uses plugins to extend its core functionality. For publishing artifacts to Maven-compatible repositories, we use the maven-publish plugin.

This powerful plugin provides the necessary tasks and a Domain Specific Language (DSL) to configure exactly what and where you want to publish.

Applying the Plugin

The first step is to apply the maven-publish plugin in your build.gradle file. We typically also apply the java plugin if we're publishing a Java library.

Don't forget to define your project's group and version, as these are critical metadata for your published artifact!

plugins {
    id 'java'
    id 'maven-publish'
}

group = 'com.coddykit.mylib'
version = '1.0.0'

// Minimal task to compile Java for publishing
java {
    withSourcesJar()
    withJavadocJar()
}

Defining a Publication

Inside the publishing block, you define one or more publications. Each publication specifies what artifacts (e.g., your main JAR, source JAR, Javadoc JAR) will be part of that release.

The from components.java line tells Gradle to include all the standard Java component artifacts (like the compiled JAR) in this publication.

plugins {
    id 'java'
    id 'maven-publish'
}

group = 'com.coddykit.mylib'
version = '1.0.0'

java {
    withSourcesJar()
    withJavadocJar()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            groupId = project.group
            artifactId = 'my-awesome-lib'
            version = project.version

            from components.java // Includes the main JAR
        }
    }
}

Adding Sources & Javadoc

It's good practice to publish your project's source code and Javadoc documentation along with the compiled JAR. This helps consumers understand and debug your library.

The java plugin's withSourcesJar() and withJavadocJar() methods simplify creating these additional artifacts.

plugins {
    id 'java'
    id 'maven-publish'
}

group = 'com.coddykit.mylib'
version = '1.0.0'

java {
    withSourcesJar()
    withJavadocJar()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            groupId = project.group
            artifactId = 'my-awesome-lib'
            version = project.version

            from components.java
            artifact sourcesJar // Add sources JAR
            artifact javadocJar // Add Javadoc JAR
        }
    }
}

// These tasks are automatically created by withSourcesJar()/withJavadocJar()
// but shown here for clarity if you need custom configuration.
// task sourcesJar(type: Jar) { from sourceSets.main.allSource archiveClassifier.set('sources') }
// task javadocJar(type: Jar) { from javadoc.destinationDir archiveClassifier.set('javadoc') }

Configuring Repositories

Now you need to tell Gradle *where* to publish your artifacts. This is done in the repositories block within publishing.

You can define multiple target repositories, including local ones for testing or remote ones like your company's Artifactory/Nexus instance.

plugins {
    id 'java'
    id 'maven-publish'
}

group = 'com.coddykit.mylib'
version = '1.0.0'

java { withSourcesJar(); withJavadocJar() }

publishing {
    publications {
        mavenJava(MavenPublication) { /* ... */ }
    }
    repositories {
        mavenLocal() // Publishes to your local Maven cache (~/.m2/repository)
        maven {
            name = "myCompanyRepo"
            url = uri("https://mycompany.com/maven-repo")
            // Credentials will be added here
        }
    }
}

Secure Credentials

For remote repositories, you'll almost always need authentication. It's vital to handle credentials securely and avoid hardcoding them directly in your build.gradle file.

  • Environment Variables: Use System.getenv('VAR_NAME') to read from system environment variables.
  • Project Properties: Access properties via project.properties['propName'], which can be set in gradle.properties or passed via command line (-PpropName=value).
plugins { id 'java'; id 'maven-publish' }
group = 'com.coddykit.mylib'; version = '1.0.0'
java { withSourcesJar(); withJavadocJar() }
publishing {
    publications { mavenJava(MavenPublication) { /* ... */ } }
    repositories {
        maven {
            name = "myCompanyRepo"
            url = uri("https://mycompany.com/maven-repo")
            credentials {
                // Securely retrieve username and password
                username = project.properties['repoUser'] ?: System.getenv('REPO_USER')
                password = project.properties['repoPass'] ?: System.getenv('REPO_PASS')
            }
        }
    }
}

Executing the Publish Task

Once your build.gradle is configured, Gradle automatically generates publishing tasks. The main task is publish, which publishes all defined publications to all configured repositories.

You can also target specific publications or repositories, e.g., publishMavenJavaPublicationToMyCompanyRepo.

# To publish all configured publications to all repositories:
gradle publish

# To publish a specific publication to a specific repository:
gradle publishMavenJavaPublicationToMyCompanyRepo

Publishing Quiz

You are configuring a build.gradle file to publish a Java library to a remote repository named "MyCompanyRepo".

Recap: Publish with Gradle

Fantastic work! You've successfully navigated the essentials of publishing artifacts with Gradle.

You now know how to:

  • Apply the maven-publish plugin.
  • Define what artifacts to publish using a MavenPublication.
  • Configure target repositories, including secure authentication.
  • Execute Gradle publish tasks to share your project's outputs.

This skill is fundamental for creating reusable libraries and integrating with CI/CD pipelines!

Questions Fréquemment Posées

La leçon « Publication dans des dépôts » est-elle gratuite ?

Oui — le texte complet de « Publication dans des dépôts » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Groovy & Gradle: JVM Automation and Build Engineering, passe à CoddyKit PRO. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Publication dans des dépôts » ?

Publiez les artefacts de votre projet dans les dépôts Maven Central, Artifactory ou Nexus. Tu pratiques Groovy & Gradle: JVM Automation and Build Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Groovy & Gradle: JVM Automation and Build Engineering ?

Aucune expérience préalable n'est requise. Groovy & Gradle: JVM Automation and Build Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Publication dans des dépôts » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Groovy & Gradle: JVM Automation and Build Engineering ?

Oui. Chaque leçon Groovy & Gradle: JVM Automation and Build Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Empaquetage de JAR, WAR et EAR
  2. Publication dans des dépôts
  3. Intégration CI/CD
  4. Versionnement et automatisation des versions
← Retour à Groovy & Gradle: JVM Automation and Build Engineering