streamalism.org

1. Introduksjon

I denne opplæringen skal vi se på hvordan du bygger et Spring Boot-prosjekt til en tynn JAR-fil ved hjelp av spring-boot-thin-launcher prosjekt.

Spring Boot er kjent for sine "fete" JAR-distribusjoner, hvor en enkelt kjørbar gjenstand inneholder både applikasjonskoden og alle dens avhengigheter.

Boot er også mye brukt til å utvikle mikrotjenester. Dette kan noen ganger være i strid med den "fete JAR" -tilnærmingen, fordi å inkludere de samme avhengighetene igjen og igjen i mange gjenstander kan bli et viktig sløsing med ressurser.

2. Forutsetninger

Først og fremst trenger vi selvfølgelig et Spring Boot-prosjekt. I denne artikkelen ser vi på Maven builds, og Gradle builds i de vanligste konfigurasjonene.

Det er umulig å dekke alle byggesystemene og bygge konfigurasjoner der ute, men forhåpentligvis ser vi nok av de generelle prinsippene for at du skal kunne bruke dem til ditt spesifikke oppsett.

2.1. Maven Prosjekter

I et Boot-prosjekt bygget med Maven, burde vi ha Spring Boot Maven-plugin konfigurert i prosjektet vårt pom.xml filen, dens overordnede eller en av dens forfedre:

 org.springframework.boot spring-boot-maven-plugin 

Versjonen av Spring Boot-avhengigheter bestemmes vanligvis ved å bruke en stykkliste eller arve fra en foreldre-POM som i vårt referanseprosjekt:

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE 

2.2. Gradle Prosjekter

I et Boot-prosjekt bygget med Gradle, har vi Boot Gradle-plugin:

buildscript {ext {springBootPlugin = 'org.springframework.boot: spring-boot-gradle-plugin' springBootVersion = '2.2.2.RELEASE'} repositories {mavenCentral ()} avhengigheter {classpath ("$ {springBootPlugin}: $ {springBootVersion } ")}} // elided bruke plugin: 'org.springframework.boot' bruke plugin: 'io.spring.dependency-management' springBoot {mainClassName = 'com.baeldung.DemoApplication'}

Merk at i denne artikkelen vil vi bare vurdere Boot 2.x og senere prosjekter. The Thin Launcher støtter også tidligere versjoner, men det krever en litt annen Gradle-konfigurasjon som vi utelater for enkelhets skyld. Se på prosjektets hjemmeside for mer informasjon.

3. Hvordan lage en tynn JAR?

Spring Boot Thin Launcher er et lite bibliotek som leser en gjenstands avhengighet fra en fil som er samlet i selve arkivet, laster dem ned fra et Maven-arkiv og til slutt starter hovedklassen i applikasjonen.

Så, når vi bygger et prosjekt med biblioteket, får vi en JAR-fil med koden vår, en fil som teller dens avhengigheter, og hovedklassen fra biblioteket som utfører oppgavene ovenfor.

Selvfølgelig er ting litt mer nyansert enn vår forenklede forklaring; Vi diskuterer noen emner i dybden senere i artikkelen.

4. Grunnleggende bruk

La oss nå se hvordan vi bygger en "tynn" JAR fra vårt vanlige Spring Boot-program.

Vi starter applikasjonen med det vanlige java -jar, med valgfrie ekstra kommandolinjeargumenter som styrer Thin Launcher. Vi ser et par av dem i de følgende avsnittene; prosjektets hjemmeside inneholder hele listen.

4.1. Maven Prosjekter

I et Maven-prosjekt må vi endre erklæringen om Boot-plugin (se avsnitt 2.1) for å inkludere en avhengighet av det tilpassede "tynne" oppsettet:

 org.springframework.boot spring-boot-maven-plugin org.springframework.boot.experimental spring-boot-thin-layout 1.0.11.RELEASE 

Lanseringsprogrammet vil lese avhengigheter fra pom.xml fil som Maven lagrer i den genererte JAR i META-INF / maven katalog.

Vi utfører byggingen som vanlig, f.eks. Med mvn installere.

Hvis vi vil være i stand til å produsere både tynne og fettbygg (for eksempel i et prosjekt med flere moduler), kan vi erklære det tilpassede oppsettet i en dedikert Maven-profil.

4.2. Maven og avhengigheter: tynn. eiendommer

Vi kan også få Maven til å generere en tynn. eiendommer fil i tillegg til pom.xml. I så fall vil filen inneholde en fullstendig liste over avhengigheter, inkludert transitive, og lanseringsprogrammet foretrekker det fremfor pom.xml.

Mojo (plugin) for å gjøre det er spring-boot-thin-maven-plugin: egenskaper, og som standard utganger tynn. eiendommer fil i src / main / resources / META-INF, men vi kan spesifisere plasseringen med tynn. utgang eiendom:

$ mvn org.springframework.boot.experimental: spring-boot-thin-maven-plugin: egenskaper -Dthin.output =.

Vær oppmerksom på at utdatakatalogen må eksistere for at målet skal lykkes, selv om vi har beholdt standardkatalogen.

4.3. Gradle Prosjekter

I et Gradle-prosjekt legger vi i stedet til et dedikert plugin:

buildscript {ext {// ... thinPlugin = 'org.springframework.boot.experimental: spring-boot-thin-gradle-plugin' thinVersion = '1.0.11.RELEASE'} // ... avhengigheter {//. .. classpath ("$ {thinPlugin}: $ {thinVersion}")}} // elided bruke plugin: 'maven' bruke plugin: 'org.springframework.boot.experimental.thin-launcher'

For å oppnå en tynn struktur, vil vi be Gradle om å utføre thinJar oppgave:

~ / projects / baeldung / spring-boot-gradle $ ./gradlew thinJar

4.4. Gradering og avhengighet: pom.xml

I kodeeksemplet i forrige seksjon har vi erklært Maven-pluginet i tillegg til Thin Launcher (i tillegg til Boot and Dependency Management-pluginene som vi allerede hadde sett i delen Forutsetninger).

Det er fordi, akkurat som i Maven-saken som vi har sett tidligere, vil gjenstanden inneholde og bruke en pom.xml fil som viser programmets avhengighet. De pom.xml filen genereres av en oppgave som heter thinPom, som er en implisitt avhengighet av enhver krukkeoppgave.

Vi kan tilpasse det genererte pom.xml fil med en dedikert oppgave. Her replikerer vi bare det tynne pluginet allerede gjør automatisk:

oppgave createPom {def basePath = 'build / resources / main / META-INF / maven' doLast {pom {withXml (dependencyManagement.pomConfigurer)} .writeTo ("$ {basePath} / $ {project.group} / $ {project. navn} /pom.xml ")}}

For å bruke vår skikk pom.xml fil, legger vi til ovennevnte oppgave i avhengighet av jaroppgaven:

bootJar.dependsOn = [createPom]

4.5. Gradering og avhengighet: tynn. eiendommer

Vi kan også få Gradle til å generere en tynn. eiendommer filen i stedet for pom.xml, som vi gjorde tidligere med Maven.

Oppgaven som genererer tynn. eiendommer filen kalles tynnEiendommer, og den brukes ikke som standard. Vi kan legge det til som en avhengighet av glassoppgaven:

bootJar.dependsOn = [thinProperties]

5. Lagring av avhengigheter

Hele poenget med tynne krukker er å unngå å bunke avhengighetene med applikasjonen. Imidlertid forsvinner avhengigheter ikke magisk, de lagres ganske enkelt andre steder.

Spesielt bruker Thin Launcher Maven-infrastrukturen til å løse avhengigheter, så:

1. den sjekker det lokale Maven-depotet, som som standard ligger i ~ / .m2 / repository men kan flyttes andre steder;
2. deretter laster den ned manglende avhengigheter fra Maven Central (eller et annet konfigurert lager);
3. til slutt cacher de dem i det lokale depotet, slik at det ikke trenger å laste dem ned neste gang vi kjører applikasjonen.

Selvfølgelig, nedlastingsfasen er den langsomme og feilutsatte delen av prosessen, fordi det krever tilgang til Maven Central via Internett, eller tilgang til en lokal proxy, og vi vet alle hvordan disse tingene generelt er upålitelige.

Heldigvis er det forskjellige måter å distribuere avhengighetene sammen med applikasjonen (e), for eksempel i en ferdigpakket container for skyutplassering.

5.1. Kjører programmet for oppvarming

Den enkleste måten å cache avhengighetene på er å gjøre en oppvarming av applikasjonen i målmiljøet. Som vi har sett tidligere, vil dette føre til at avhengighetene lastes ned og caches i det lokale Maven-depotet. Hvis vi kjører mer enn en app, vil depotet ende med å inneholde alle avhengighetene uten duplikater.

Siden kjøring av et program kan ha uønskede bivirkninger, Vi kan også utføre en "tørr kjøring" som bare løser og laster ned avhengighetene uten å kjøre noen brukerkode:

$ java -Dthin.dryrun = true -jar my-app-1.0.jar

Merk at vi i henhold til Spring Boot-konvensjoner kan stille inn -Dthin.dryrun eiendom også med en –Thin.dryrun kommandolinjeargument til applikasjonen eller med en THIN_DRYRUN systemegenskap. Enhver verdi unntatt falsk vil instruere Thin Launcher om å utføre en tørr løp.

5.2. Pakke avhengighetene under byggingen

Et annet alternativ er å samle avhengighetene under bygningen, uten å samle dem i JAR. Deretter kan vi kopiere dem til målmiljøet som en del av distribusjonsprosedyren.

Dette er generelt enklere fordi det ikke er nødvendig å kjøre applikasjonen i målmiljøet. Imidlertid, hvis vi distribuerer flere applikasjoner, må vi slå sammen deres avhengigheter, enten manuelt eller med et skript.

Formatet der Thin Plugin for Maven og Gradle pakker avhengighetene under en build, er det samme som et Maven lokalt arkiv:

root / repository / com / net / org / ...

Faktisk kan vi peke et program som bruker Thin Launcher til en hvilken som helst slik katalog (inkludert et lokalt Maven-arkiv) ved kjøretid med tynn. rot eiendom:

$ java -jar my-app-1.0.jar --thin.root = min-app / deps

Vi kan også trygt slå sammen flere slike kataloger ved å kopiere dem over hverandre, og dermed oppnå et Maven-arkiv med alle nødvendige avhengigheter.

5.3. Pakke avhengighetene med Maven

For å få Maven til å pakke avhengighetene for oss, bruker vi Løse målet for spring-boot-thin-maven-plugin. Vi kan påberope det manuelt eller automatisk i vårt pom.xml:

 org.springframework.boot.experimental spring-boot-thin-maven-plugin $ {thin.version} løse løse falske 

Etter at vi har bygget prosjektet, finner vi en katalog mål / tynn / rot / med strukturen som vi har diskutert i forrige avsnitt.

5.4. Pakke avhengighetene med Gradle

Hvis vi bruker Gradle med tynn bærerakett plugin, i stedet har vi en tynnResolve oppgave tilgjengelig. Oppgaven vil lagre applikasjonen og dens avhengigheter i bygge / tynn / rot / katalog, på samme måte som Maven-pluginet i forrige avsnitt:

$ gradlew thinResolve

Vær oppmerksom på at, i skrivende stund, tynn bærerakett plugin har en feil som forhindrer at avhengighetene lagres hvis tynn. eiendommer brukes: //github.com/dsyer/spring-boot-thin-launcher/issues/53.

6. Konklusjoner og videre lesing

I denne artikkelen har vi sett på hvordan vi lager vår tynne krukke. Vi har også sett hvordan du bruker Maven-infrastrukturen til å laste ned og lagre deres avhengighet.

Hjemmesiden til den tynne bæreraketten har noen flere HVORDAN-guider for scenarier som skyutplasseringer til Heroku, samt den komplette listen over støttede kommandolinjeargumenter.

Implementeringen av alle Maven-eksemplene og kodebitene finner du i GitHub-prosjektet - som et Maven-prosjekt, så det skal være enkelt å importere og kjøre som det er.

Tilsvarende refererer alle Gradle-eksempler til dette GitHub-prosjektet.