Groovy og Gradle: JVM-automatisering og byggeutvikling · leksjon

Deklarering av prosjektavhengigheter

Lær ulike måter å deklarere avhengigheter på i `build.gradle` for forskjellige omfang og typer.

Leksjon 1 av 411 trinn

Deklarering av prosjektavhengigheter er en gratis leksjon i Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit. Dette er leksjon 1 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.

Prosjektbehov og avhengigheter

Moderne programvareprosjekter fungerer sjelden isolert. De er ofte avhengige av ekstern kode, kjent som avhengigheter, for å utføre ulike oppgaver.

Tenk på avhengigheter som ferdigbygde verktøy eller biblioteker som sparer deg for å skrive vanlig funksjonalitet fra grunnen av, for eksempel logging, tolking av JSON eller tilkobling til en database.

Biblioteker: Samlinger av kode (f.eks. Apache Commons).
Rammeverk: Strukturerte grunnlag for applikasjoner (f.eks. Spring Boot).
Moduler: Komponenter i et større system.

Gradles `dependencies`-blokk

I Gradle deklarerer du alle prosjektets avhengigheter i en egen dependencies { ... }-blokk i filen build.gradle.

Denne blokken er sentral for å håndtere det prosjektet trenger for å kompilere, teste og kjøre.

/* build.gradle */

plugins {
  id 'java'
}

repositories {
  mavenCentral()
}

dependencies {
  // Your dependencies go here!
}

Hvor Gradle finner avhengigheter

Før Gradle kan hente avhengigheter, må den vite hvor den skal lete. Dette defineres i blokken repositories { ... }.

Det vanligste repositoriet er Maven Central, et stort offentlig repositorium for Java-biblioteker. Ved å deklarere mavenCentral() ber du Gradle om å søke der.

/* build.gradle */

repositories {
  // Tells Gradle to look for dependencies in Maven Central
  mavenCentral()
}

`implementation`: standardvalget

Konfigurasjonen implementation er førstevalget for de fleste avhengigheter i produksjonskode. Den legger avhengigheten til både kompilerings-classpathen og runtime-classpathen.

Det er viktig at implementation-avhengigheter ikke eksponeres for andre moduler som bruker prosjektet ditt. Dette bidrar til raskere kompilering og bedre innkapsling.

/* build.gradle */

dependencies {
  // Adds SLF4J API for logging, used during compile and runtime
  implementation 'org.slf4j:slf4j-api:1.7.30'
}

Eksempel: Bruke `implementation`

La oss se på en enkel Java-klasse som bruker et bibliotek lagt til med implementation. Vi legger til Apache Commons Lang-biblioteket for strengverktøy.

/* build.gradle */

plugins {
  id 'java'
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'org.apache.commons:commons-lang3:3.12.0'
}

/* src/main/java/App.java */

import org.apache.commons.lang3.StringUtils;

public class App {
  public static void main(String[] args) {
    String text = "  Hello CoddyKit  ";
    System.out.println(StringUtils.trim(text));
  }
}

`testImplementation`: kun for testing

Avhengigheter som bare trengs for å kjøre tester (som JUnit 5 eller Mockito), bør deklareres med testImplementation.

Disse avhengighetene legges til i classpathene for testkompilering og testkjøring, men inkluderes ikke i det endelige applikasjonsartefaktet og eksponeres ikke for produksjonskode.

/* build.gradle */

dependencies {
  // Adds JUnit 5 for unit testing
  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
  testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}

`runtimeOnly`: kun for kjøring

Noen ganger trengs en avhengighet bare når applikasjonen faktisk kjører, ikke under kompilering. Det er her runtimeOnly kommer inn.

Et vanlig bruksområde er en JDBC-driver. Koden kompileres mot JDBC API-et (som ofte er en del av Java eller en compileOnly-avhengighet), mens den spesifikke driveren (f.eks. HSQLDB eller PostgreSQL) bare trengs under kjøring.

/* build.gradle */

dependencies {
  // JDBC driver for HSQLDB, only needed when the app runs
  runtimeOnly 'org.hsqldb:hsqldb:2.5.1'
}

`compileOnly`: hjelp under kompilering

Bruk compileOnly for avhengigheter som kreves under kompilering, men som ikke skal pakkes med den endelige applikasjonen eller være tilgjengelige under kjøring.

Eksempler er annotasjonsprosessorer som Lombok eller API-spesifikasjoner (f.eks. Servlet API) når applikasjonen skal kjøre i et miljø som allerede tilbyr dem.

/* build.gradle */

dependencies {
  // Lombok for reducing boilerplate code, not needed at runtime
  compileOnly 'org.projectlombok:lombok:1.18.20'
  annotationProcessor 'org.projectlombok:lombok:1.18.20'
}

Lokale filer som avhengigheter

Selv om det generelt frarådes, kan det hende du må inkludere en lokal JAR-fil som ikke er tilgjengelig i et offentlig repositorium (f.eks. et proprietært bibliotek).

Du kan deklarere disse ved hjelp av metoden files() i dependencies-blokken. Sørg for at banen er riktig i forhold til prosjektroten.

/* build.gradle */

dependencies {
  // Includes a JAR file located in the 'libs' folder
  implementation files('libs/my-custom-lib.jar')
}

Quiz om avhengighetskonfigurasjon

Du bygger en webapplikasjon og må inkludere:

Et loggingsbibliotek for all kode.
JUnit 5 for enhetstester.
Servlet API, som applikasjonsserveren allerede tilbyr.

Hvilke Gradle-avhengighetskonfigurasjoner vil du bruke for disse tre elementene?

Besvar den i den interaktive leksjonen

Oppsummering: Deklarere avhengigheter

Godt jobbet! Du har lært det viktigste om å deklarere avhengigheter i Gradle:

I blokken dependencies { ... } lister du opp alle eksterne biblioteker.
repositories { ... } forteller Gradle hvor disse bibliotekene finnes (f.eks. mavenCentral()).
implementation for det meste av produksjonskoden.
testImplementation for testspesifikke biblioteker.
runtimeOnly for avhengigheter som bare trengs under kjøring.
compileOnly for avhengigheter som bare trengs under kompilering og ikke pakkes med.
Du kan også inkludere lokale JAR-filer ved hjelp av files().

Hvis du forstår disse konfigurasjonene, kan du bygge effektive og velstrukturerte prosjekter!

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 «Deklarering av prosjektavhengigheter» gratis?

Ja – hele teksten i «Deklarering av prosjektavhengigheter» 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 «Deklarering av prosjektavhengigheter»?

Lær ulike måter å deklarere avhengigheter på i `build.gradle` for forskjellige omfang og typer. 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 1 av 4.

Hvor lang tid tar leksjonen «Deklarering av prosjektavhengigheter»?

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

Deklarering av prosjektavhengigheter
Avhengighetsoppløsning og hurtigbufring
Egendefinerte repositorier og BOM-er
Løse versjonskonflikter og avhengighetsbegrensninger

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