Groovy og Gradle: JVM-automatisering og byggeutvikling · leksjon

Bruke og publisere plugins

Lær hvordan De bruker egendefinerte plugins i prosjekter og publiserer dem til et lokalt eller eksternt repositorium.

Leksjon 3 av 412 trinn

Bruke og publisere plugins er en gratis leksjon i Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Groovy og Gradle: JVM-automatisering og byggeutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Gjenbruke Gradle-pluginene dine

Du har altså lært å opprette egendefinerte Gradle-pluginer. Flott! Men hvordan bruker du dem faktisk i forskjellige prosjekter, og hvordan kan du dele dem med andre?

I denne leksjonen ser vi på hvordan du bruker de egendefinerte pluginene dine i et Gradle-prosjekt, og hvordan du publiserer dem til et lokalt eller eksternt repository slik at de kan brukes av flere.

Repetisjon: Bruke pluginer

Før vi går videre til egendefinerte pluginer, skal vi raskt repetere hvordan du bruker standardpluginer.

De fleste pluginer brukes ved hjelp av blokken plugins { id 'plugin-id' } i build.gradle-filen.
Denne metoden foretrekkes fordi den er deklarativ og gir bedre støtte i verktøyene.
Den fungerer for pluginer fra Gradle Plugin Portal, lokale buildSrc-pluginer og publiserte pluginer.

Bruke skript-pluginer

Du kan definere byggelogikk direkte i build.gradle eller inkludere den fra et annet skript. Dette er den enkleste formen for gjenbruk av logikk.

Nedenfor defineres en egendefinert oppgave, myCustomTask. Den er tilgjengelig for byggeskriptet ditt på samme måte som alle andre oppgaver.

task myCustomTask {
    doLast {
        println "Hello from my custom task!"
    }
}

task executeMyTask {
    dependsOn myCustomTask
    doLast {
        println "Main build script finished after custom task."
    }
}
// To run: gradle executeMyTask

Pluginer fra buildSrc

For mer komplekse, prosjektspesifikke pluginer kompilerer Gradle automatisk alle pluginer som er definert i buildSrc-katalogen, og gjør dem tilgjengelige.

Hvis du oppretter et plugin i buildSrc/src/main/groovy/com/example/MyPlugin.groovy, kan det brukes direkte med ID-en sin:

Definer plugin: buildSrc/src/main/groovy/my.project.plugin.gradle
Bruk plugin: plugins { id 'my.project.plugin' }

Gradle sørger for at buildSrc bygges før hovedprosjektet, slik at pluginene er klare til bruk.

Hvorfor publisere pluginer?

Selv om buildSrc er flott for pluginer i ett enkelt prosjekt eller en monorepo, hva om du vil dele pluginet på tvers av helt separate prosjekter, eller til og med med fellesskapet?

Det er her publisering kommer inn. Ved å publisere gjør du pluginet tilgjengelig i et repository, akkurat som alle andre biblioteker du bruker (for eksempel fra Maven Central).

Lokalt: Del på maskinen din for personlig bruk.
Eksternt: Del i organisasjonen din (Artifactory, Nexus) eller globalt (Gradle Plugin Portal, Maven Central).

Publisere med maven-publish

Gradles maven-publish-plugin er standardmåten å publisere plugin-artefakter til Maven-kompatible repositories på.

Når du bruker dette pluginet, får du tilgang til en publishing-blokk i build.gradle, der du definerer detaljene for hva som skal publiseres, og hvordan det skal gjøres.

Det introduserer også oppgaver som publishToMavenLocal og publish.

plugins {
    id 'java-library' // Or 'groovy' for Groovy plugins
    id 'maven-publish'
}

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

// Applying maven-publish plugin
// This is part of setting up for publication.
// No direct output from this snippet alone.

Definere publiseringsdetaljer

Inne i publishing-blokken konfigurerer du detaljene for artefaktet: navnet, hvilke komponenter som skal inkluderes (for eksempel JAR-filer), og hvor det skal publiseres.

En «publisering» definerer et sett med artefakter og metadataene deres (gruppe, artefakt-ID og versjon).

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

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

publishing {
    publications {
        maven(MavenPublication) {
            // The artifact ID is usually derived from project name,
            // but can be explicitly set.
            artifactId 'my-groovy-plugin'
            from components.java // Publish the Java library component
        }
    }
}
// This defines how the plugin will be published.
// No direct output from this snippet alone.

Publisere til Maven Local

Når du har konfigurert publiseringen, kan du publisere pluginet til det lokale Maven-repositoriet ditt. Dette er nyttig for lokal testing og utvikling.

Gradle tilbyr en oppgave for hver publisering du definerer (for eksempel publishMavenPublicationToMavenLocal hvis publiseringen heter maven).

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

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

publishing {
    publications {
        maven(MavenPublication) { // 'maven' is the publication name
            artifactId 'my-groovy-plugin'
            from components.java
        }
    }
    repositories {
        mavenLocal() // Explicitly declare mavenLocal for publishing
    }
}
// To publish: gradle publishMavenPublicationToMavenLocal
// This command will build your plugin and place its artifacts
// into your local Maven cache (~/.m2/repository).

Bruke et publisert plugin

For å bruke et plugin som du har publisert til mavenLocal(), i et annet prosjekt, trenger du to ting:

Deklarer mavenLocal(): Legg til mavenLocal() i pluginManagement.repositories-blokken i settings.gradle for prosjektet som bruker pluginet.
Bruk ID og versjon: Bruk blokken plugins { id '...' version '...' } i build.gradle for prosjektet som bruker pluginet.

Dette forteller Gradle at pluginet skal hentes fra det lokale Maven-repositoriet ditt.

// settings.gradle (consuming project)
pluginManagement {
    repositories {
        mavenLocal()
        gradlePluginPortal()
    }
}

// build.gradle (consuming project)
plugins {
    id 'com.coddykit.example.my-groovy-plugin' version '1.0.0'
    // Replace 'com.coddykit.example.my-groovy-plugin' with your plugin's actual ID
}

// This code snippet shows how to apply a published plugin.
// It assumes the plugin has been published and is available locally.

Publisere eksternt

For å dele pluginet utenfor den lokale maskinen din publiserer du det til et eksternt repository. Dette kan være:

Artifactory/Nexus i bedriften: For intern bruk i teamet.
Gradle Plugin Portal: For offentlige pluginer. Dette krever pluginet com.gradle.plugin-publish.
Maven Central: Det største offentlige repositoriet.

Konfigurasjonen i blokken publishing.repositories angir URL-en og påloggingsopplysningene for disse eksterne målene.

plugins {
    id 'maven-publish'
    // id 'com.gradle.plugin-publish' // For Gradle Plugin Portal
}

publishing {
    publications {
        maven(MavenPublication) { /* ... */ }
    }
    repositories {
        maven {
            name = "myCompanyRepo"
            url = uri("https://your.company.repo/releases")
            credentials {
                username = project.properties.get("repoUsername")
                password = project.properties.get("repoPassword")
            }
        }
    }
}
// This snippet shows how to define a remote repository.
// Credentials should be managed securely, not hardcoded.

Kontroll av bruk av plugin

Det er på tide å teste forståelsen din av hvordan pluginer brukes og publiseres.

Besvar den i den interaktive leksjonen

Oppsummering: Bruke og publisere

Du har lært hvordan du gjør de egendefinerte Gradle-pluginene dine virkelig gjenbrukbare!

Du kan bruke enkle skript-pluginer med apply from:.
Pluginer i buildSrc er automatisk tilgjengelige med ID.
maven-publish-pluginet lar deg definere og publisere plugin-artefaktene dine.
Publisering til mavenLocal() er nyttig for lokal testing.
For å bruke et publisert plugin konfigurerer du mavenLocal() i settings.gradle og bruker pluginet med ID og versjon.
Eksterne repositories gjør det mulig å dele pluginer på tvers av team eller offentlig.

Nå kan du bygge kraftig og delbar byggelogikk!

Gratis å komme i gang

Lær deg Groovy med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Bruke og publisere plugins» gratis?

Ja – hele teksten i «Bruke og publisere plugins» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Groovy og Gradle: JVM-automatisering og byggeutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bruke og publisere plugins»?

Lær hvordan De bruker egendefinerte plugins i prosjekter og publiserer dem til et lokalt eller eksternt repositorium. Du øver på Groovy og Gradle: JVM-automatisering og byggeutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Groovy og Gradle: JVM-automatisering og byggeutvikling?

Ingen tidligere erfaring er nødvendig. Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Bruke og publisere plugins»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Groovy og Gradle: JVM-automatisering og byggeutvikling-leksjonen?

Ja. Alle Groovy og Gradle: JVM-automatisering og byggeutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Forstå Gradle-plugins
Bygge binære plugins
Bruke og publisere plugins
Plugin-utvidelser og konfigurerbare DSL-er

← Tilbake til Groovy og Gradle: JVM-automatisering og byggeutvikling