streamalism.org

1. Bemutatkozás

Ebben az oktatóanyagban meg fogjuk vizsgálni Hogyan készítsünk egy Spring Boot projektet egy vékony JAR fájlba a rugós-bakancs-vékony-indító projekt.

A Spring Boot a „kövér” JAR-telepítésekről ismert, ahol egyetlen futtatható artefaktum tartalmazza az alkalmazás kódját és annak összes függőségét.

A rendszerindítást széles körben használják a mikroszolgáltatások fejlesztésére is. Ez néha ellentmondhat a „kövér JAR” megközelítésnek, mert ugyanazok a függőségek sokféle műtárgyba történő belefoglalása az erőforrások jelentős pazarlásává válhat.

2. Előfeltételek

Először is szükségünk van egy Spring Boot projektre, természetesen. Ebben a cikkben a Maven buildeket és a Gradle épít a leggyakoribb konfigurációikban.

Lehetetlen lefedni az összes építési rendszert és építési konfigurációt, de remélhetőleg eléggé áttekintjük azokat az általános elveket, amelyeket képesnek kell lenned alkalmazni az adott beállításodra.

2.1. Maven Projektek

A Mavennel épített Boot projektben a Spring Boot Maven plugint kell konfigurálnunk a projektünkben pom.xml fájl, annak szülője vagy egyik őse:

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

A Spring Boot függőségek verzióját általában egy BOM használatával vagy egy szülő POM-tól való örökléssel döntik el, mint a referencia projektünkben:

 org.springframework.boot spring-boot-starter-parent 2.2.2.KÖZLEMÉNY 

2.2. Gradle Projects

A Gradle-lel épített Boot projektben megvan a Boot Gradle plugin:

buildscript {ext {springBootPlugin = 'org.springframework.boot: spring-boot-gradle-plugin' springBootVersion = '2.2.2.RELEASE'} adattárak {mavenCentral ()} függőségek {classpath ("$ {springBootPlugin}: $ {springBootVersion } ")}} // elided Apply plugin: 'org.springframework.boot' Apply plugin: 'io.spring.dependency-management' springBoot {mainClassName = 'com.baeldung.DemoApplication'}

Vegye figyelembe, hogy ebben a cikkben csak a Boot 2.x és későbbi projekteket vesszük figyelembe. A Thin Launcher a korábbi verziókat is támogatja, de egy kicsit más Gradle konfigurációt igényel, amelyet az egyszerűség kedvéért kihagyunk. Kérjük, nézze meg a projekt honlapját további részletekért.

3. Hogyan hozzunk létre egy vékony JAR-t?

A Spring Boot Thin Launcher egy kis könyvtár, amely a műtárgy függőségeit kiolvassa egy archívumban lévő fájlból, letölti azokat a Maven tárából, és végül elindítja az alkalmazás fő osztályát.

Így, amikor egy projektet építünk a könyvtárral, kapunk egy JAR fájlt a kódunkkal, egy fájlt, amely felsorolja annak függőségeit, és a fő osztályt a könyvtárból, amely a fenti feladatokat elvégzi.

Természetesen a dolgok valamivel árnyaltabbak, mint az egyszerűsített magyarázatunk; néhány témát alaposan megvitatunk a cikk későbbi részében.

4. Alapvető használat

Most nézzük meg, hogyan lehet egy „vékony” JAR-ot felépíteni a szokásos Spring Boot alkalmazásunkból.

Az alkalmazást a szokásos módon indítjuk el java -jar, opcionális kiegészítő parancssori argumentumokkal, amelyek vezérlik a Vékony Launchert. Párat meglátunk a következő szakaszokban; a projekt honlapja tartalmazza a teljes listát.

4.1. Maven Projektek

Egy Maven projektben módosítanunk kell a Boot plugin deklarációját (lásd a 2.1. Szakaszt), hogy az tartalmazzon függőséget az egyedi „vékony” elrendezéstől:

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

Az indító a függőségeket olvassa le a pom.xml fájl, amelyet a Maven a létrehozott JAR-ban tárol a META-INF / maven Könyvtár.

A szerkesztést a szokásos módon hajtjuk végre, pl mvn install.

Ha vékony és zsíros összeállítást is elő akarunk állítani (például egy több modulos projektben), akkor deklarálhatjuk az egyedi elrendezést egy dedikált Maven-profilban.

4.2. Maven és függőségek: vékony.tulajdonságok

Azt is megtehetjük, hogy Maven generál egy vékony.tulajdonságok fájl mellett pom.xml. Ebben az esetben a fájl tartalmazza a függőségek teljes listáját, beleértve a tranzitívakat is, és az indító inkább a pom.xml.

Az erre szolgáló mojo (plugin) az spring-boot-thin-maven-plugin: tulajdonságok, és alapértelmezés szerint a vékony.tulajdonságok fájl src / main / resources / META-INF, de megadhatjuk a helyét a vékony.kimenet ingatlan:

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

Felhívjuk figyelmét, hogy a kimeneti könyvtárnak léteznie kell a cél sikeréhez, még akkor is, ha megtartottuk az alapértelmezettet.

4.3. Gradle Projects

A Gradle projektben ehelyett egy dedikált bővítményt adunk hozzá:

buildscript {ext {// ... thinPlugin = 'org.springframework.boot.experimental: spring-boot-thin-gradle-plugin' thinVersion = '1.0.11.RELEASE'} // ... függőségek {//. .. classpath ("$ {thinPlugin}: $ {thinVersion}")}}} // elided plug plugin: 'maven' Apply plugin: 'org.springframework.boot.experimental.thin-launcher'

A vékony összeállítás megszerzéséhez meg fogjuk szólítani Gradle-t, hogy hajtsa végre a vékonyJar feladat:

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

4.4. Fokozat és függőségek: pom.xml

Az előző szakaszban található kód példában a Maven plugint deklaráltuk a Thin Launcher mellett (valamint a Boot és Dependency Management beépülő modulokat, amelyeket már az Előfeltételek részben láttunk).

Ez azért van, mert a műtárgy, csakúgy, mint a korábban látott Maven-ügyben, tartalmazni fogja a pom.xml az alkalmazás függőségeit felsoroló fájl. A pom.xml fájlt az úgynevezett feladat generálja vékonyPom, amely minden jar feladat implicit függősége.

Testreszabhatjuk a létrehozottakat pom.xml fájl dedikált feladattal. Itt csak megismételjük, amit a vékony plugin már automatikusan elvégez:

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

Hogy használjuk szokásunkat pom.xml fájlt, hozzáadjuk a fenti feladatot a jar feladat függőségeihez:

bootJar.dependsOn = [createPom]

4.5. Fokozat és függőségek: vékony.tulajdonságok

Azt is megtehetjük, hogy Gradle generál egy vékony.tulajdonságok fájl helyett pom.xml, mint korábban Mavennel tettük.

Az a feladat, amely a vékony.tulajdonságok fájl neve vékony tulajdonságok, és alapértelmezés szerint nem használják. Hozzáadhatjuk a jar feladat függőségeként:

bootJar.dependsOn = [vékony tulajdonságok]

5. A függőségek tárolása

A vékony üvegek lényege, hogy elkerüljék a függőségek alkalmazással való összekapcsolását. A függőségek azonban nem tűnnek el varázsütésre, egyszerűen máshol tárolódnak.

Különösen a Thin Launcher használja a Maven infrastruktúrát a függőségek megoldására, így:

1. ellenőrzi a helyi Maven adattárat, amely alapértelmezés szerint a ~ / .m2 / adattár de máshová költözhető;
2. majd letölti a hiányzó függőségeket a Maven Central-ból (vagy bármely más konfigurált adattárból);
3. végül gyorsítótárba helyezi őket a helyi adattárban, hogy az alkalmazás következő futtatásakor ne kelljen újra letöltenie őket.

Természetesen, a letöltési szakasz a folyamat lassú és hibára hajlamos része, mert ehhez interneten keresztül vagy a helyi proxyhoz kell hozzáférni a Maven Centralhoz, és mindannyian tudjuk, hogy ezek a dolgok általában megbízhatatlanok.

Szerencsére a függőségek alkalmazással (alkalmazásokkal) történő telepítésének számos módja van, például felhőalapú telepítéshez előre csomagolt tárolóban.

5.1. A Warm-up alkalmazás futtatása

A függőségek gyorsítótárának legegyszerűbb módja az alkalmazás bemelegítő futtatása a célkörnyezetben. Amint azt korábban láthattuk, ez a függőségek letöltését és gyorsítótárba helyezését eredményezi a helyi Maven-tárban. Ha egynél több alkalmazást futtatunk, a lerakat az összes függőséget duplikátumok nélkül tartalmazza.

Mivel egy alkalmazás futtatásának lehetnek nem kívánt mellékhatásai, elvégezhetünk egy „száraz futtatást” is, amely csak a függőségeket oldja meg és tölti le felhasználói kód futtatása nélkül:

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

Vegye figyelembe, hogy a Spring Boot konvencióknak megfelelően beállíthatjuk a -Dthin.száradás ingatlan is a –Vékony.száradás parancssori argumentum az alkalmazáshoz vagy a THIN_DRYRUN rendszer tulajdonság. Bármely érték, kivéve hamis utasítja a Thin Launcher-t, hogy végezzen száraz futtatást.

5.2. A függőségek csomagolása az összeállítás során

Egy másik lehetőség a függőségek összegyűjtése az összeállítás során, anélkül, hogy azokat a JAR-ba kötnénk. Ezután átmásolhatjuk őket a célkörnyezetbe a telepítési eljárás részeként.

Ez általában egyszerűbb, mert nem szükséges futtatni az alkalmazást a célkörnyezetben. Ha azonban több alkalmazást telepítünk, össze kell egyesítenünk a függőségüket, akár manuálisan, akár egy szkript segítségével.

Az a formátum, amelyben a Maven és Gradle vékony beépülő modulja összeépíti a függőségeket egy build során, megegyezik egy Maven helyi adattárral:

root / adattár / com / net / org / ...

Valójában a Thin Launcher segítségével egy alkalmazást futás közben bármelyik ilyen könyvtárba (beleértve a helyi Maven tárhelyet is) irányíthatunk. vékony.gyökér ingatlan:

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

Több ilyen könyvtárat is biztonságosan egyesíthetünk úgy, hogy egymásba másoljuk őket, így megszerezhetjük az összes szükséges függőséggel rendelkező Maven-tárházat.

5.3. A függőségek csomagolása Maven-szel

Ahhoz, hogy Maven csomagolja a függőségeket számunkra, használjuk a elhatározás célja a spring-boot-thin-maven-plugin. Hívhatjuk manuálisan vagy automatikusan a mi pom.xml:

 org.springframework.boot.experimental spring-boot-thin-maven-plugin $ {thin.version} megoldja a hamis megoldást 

A projekt elkészítése után találunk egy könyvtárat cél / vékony / gyökér / az előző szakaszban tárgyalt struktúrával.

5.4. A függőségek csomagolása fokozattal

Ha Gradle-t használjuk a vékonyindító plugin, ehelyett van egy vékonyResolve feladat elérhető. A feladat menteni fogja az alkalmazást és annak függőségeit a build / vékony / root / könyvtár, hasonlóan az előző szakasz Maven beépülő moduljához:

$ gradlew thinResolve

Felhívjuk figyelmét, hogy az írás idején a vékonyindító A plugin hibája megakadályozza a függőségek mentését, ha vékony.tulajdonságok használatos: //github.com/dsyer/spring-boot-thin-launcher/issues/53.

6. Következtetések és további olvasmányok

Ebben a cikkben megvizsgáltuk, hogyan készítsük el vékony edényünket. Láttuk azt is, hogyan lehet a Maven infrastruktúrát használni függőségeik letöltésére és tárolására.

A vékony hordozórakéta kezdőlapján van még néhány HOGYAN útmutató az olyan esetekhez, mint a felhő Heroku-telepítése, valamint a támogatott parancssori argumentumok teljes listája.

Az összes Maven-példa és kódrészlet megvalósítása megtalálható a GitHub projektben - Maven-projektként, így könnyen importálhatónak és futtathatónak kell lennie.

Hasonlóképpen, az összes Gradle példa erre a GitHub projektre vonatkozik.