0Pricing
Groovy & Gradle: JVM Automation and Build Engineering · Lektion

In Repositories veröffentlichen

Veröffentlichen Sie Ihre Projektartefakte in Maven-Central-, Artifactory- oder Nexus-Repositories.

In Repositories veröffentlichen ist eine kostenlose Groovy & Gradle: JVM Automation and Build Engineering-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Groovy & Gradle: JVM Automation and Build Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Groovy & Gradle: JVM Automation and Build Engineering-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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!

Häufig gestellte Fragen

Ist die Lektion „In Repositories veröffentlichen“ kostenlos?

Ja — der vollständige Text von „In Repositories veröffentlichen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Groovy & Gradle: JVM Automation and Build Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Groovy & Gradle: JVM Automation and Build Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „In Repositories veröffentlichen“?

Veröffentlichen Sie Ihre Projektartefakte in Maven-Central-, Artifactory- oder Nexus-Repositories. Du übst Groovy & Gradle: JVM Automation and Build Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Groovy & Gradle: JVM Automation and Build Engineering zu starten?

Keine Vorkenntnisse erforderlich. Groovy & Gradle: JVM Automation and Build Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „In Repositories veröffentlichen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Groovy & Gradle: JVM Automation and Build Engineering-Lektion Code schreiben und ausführen?

Ja. Jede Groovy & Gradle: JVM Automation and Build Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. JARs, WARs und EARs paketieren
  2. In Repositories veröffentlichen
  3. CI/CD-Integration
  4. Versionierung und Release-Automatisierung
← Zurück zu Groovy & Gradle: JVM Automation and Build Engineering