Egyéni Gradle bővítmények írása
• Ant vs Maven vs Gradle
• Egyéni Gradle bővítmények írása (aktuális cikk) • Zsíros edény létrehozása Gradle-ben
1. Bemutatkozás
A Gradle egy nagyon népszerű buildeszköz, amelyet gyakran értékelnek a nagyon testreszabható összeállítási folyamat miatt.
Ma bemutatjuk, hogyan hozhatunk létre egyedi Gradle beépülő modulokat, amelyek lehetővé teszik számunkra, hogy módosítsuk az összeállítási folyamatot azon túl, amit a standard konfigurációval elérhetünk.
2. Bővítményforrás helye
Helyezhetjük kódunkat néhány különböző helyre. Mindegyiküknek vannak előnyei és hátrányai.
2.1. Build szkript
A pluginünk forráskódját egyszerűen magába a build szkriptbe helyezhetjük. Ez lehetővé teszi számunkra a plugin automatikus fordítását és beépítését.
Nagyon egyszerű, azonban a bővítményünk nem lesz látható a build szkripten kívül. Emiatt nem használhatjuk fel más build szkriptekben.
2.2. BuildSrc Mappa
Egy másik lehetőség, amelyet felhasználhatunk, a plugin forráskódjának elhelyezése a buildSrc / src / main / java mappába.
A Gradle futtatásakor ellenőrizni fogja a buildSrc mappába. Ha ez létezik, a Gradle automatikusan elkészíti és beépíti a bővítményünket.
Ez lehetővé teszi számunkra, hogy megosszuk a beépülő modulunkat a különféle build szkriptek között, de más projektekben továbbra sem tudjuk használni.
2.3. Önálló projekt
Végül létrehozhatjuk a beépülő modulunkat külön projektként, amely a plugint teljesen újrafelhasználhatóvá teszi a különböző projektekben.
Külső projektben történő felhasználáshoz azonban egy jar fájlba kell csomagolnia, és hozzá kell adnunk egy projekthez.
3. Első bővítményünk
Kezdjük az alapokkal - minden Gradle beépülő modulnak végre kell hajtania a com.gradle.api.Plugin felület.
Az interfész általános, ezért különböző paramétertípusokkal paraméterezhetjük. Általában a paraméter típusa az org.gradle.api.Project.
Különböző típusú paramétereket használhatunk azonban úgy, hogy a beépülő modult az élet különböző szakaszaiban alkalmazzuk:
- felhasználásával org.gradle.api.Beállítások a plugin alkalmazását eredményezi egy beállítási szkriptnél
- felhasználásával org.gradle.api.Gradle a plugin alkalmazását eredményezi az inicializáló szkriptnél
A legegyszerűbb beépülő modul, amelyet létrehozhatunk, a Helló Világ Alkalmazás:
public class GreetingPlugin implementálja a beépülő modult {@Orride public void Apply (Project project) {project.task ("hello") .doLast (task -> System.out.println ("Hello Gradle!")); }}
Most már alkalmazhatjuk, ha egy sort adunk a build szkriptünkbe:
plugin alkalmazása: GreetingPlugin
Most, miután hívott fokozat köszön, meglátjuk „Hello Gradle” üzenet a naplókban.
4. A beépülő modul beállítása
A legtöbb beépülő modulnak hozzá kell férnie egy külső konfigurációhoz a build szkriptből.
Megtehetjük a használatával kiterjesztésű objektumok:
public class GreetingPluginExtension {private String greeter = "Baeldung"; private String message = "Üzenet a bővítménytől!" // szabványos mérőeszközök és beállítók}
Most tegyük hozzá az újat kiterjesztés objektum a plugin osztályunkba:
@Orride public void apply (Projekt projekt) {GreetingPluginExtension extension = project.getExtensions () .create ("üdvözlet", GreetingPluginExtension.class); project.task ("hello") .doLast (task -> {System.out.println ("Hello," + extension.getGreeter ()); System.out.println ("Van egy üzenetem Neked:" + kiterjesztés .getMessage ());}); }
Most, amikor hívunk fokozat köszön, látni fogjuk az alapértelmezett üzenetet, amelyet a GreetingPluginExtension.
De mivel létrehoztuk a kiterjesztést, használhatunk egy lezárást a build szkript belsejében:
üdvözlet {greeter = "Stranger" message = "Üzenet a build szkriptből"}
5. Önálló beépülő modul
Az önálló Gradle beépülő modulok létrehozásához egy kicsit több munkát kell elvégeznünk.
5.1. Beállít
Először is importálnunk kell a Gradle API-függőséget - ami nagyon egyszerű:
függőségek {compile gradleApi ()}
Ne feledje, hogy ugyanezt Mavenben megköveteli gradle-tooling-api függőség - a Gradle adattárból:
org.gradle gradle-tooling-api 3.0 org.gradle gradle-core 3.0 nyújtott repo.gradle.org //repo.gradle.org/gradle/libs-releases-local/
5.2. A Plugin bekötése
Ahhoz, hogy Gradle megtalálhassa önálló beépülő modulunk megvalósítását, létre kell hoznunk a tulajdonságfájlt a src / main / resources / META-INF /gradle-bővítmények.
Az erőforrásfájlnak olyan nevet kell tartalmaznia, amely megegyezik a beépülő modul azonosítójával. Tehát ha a bővítményünk azonosítója: org.baeldung.greeting, a fájl pontos elérési útja lenne META-INF / gradle-plugins / org.baeldung.greeting.properties.
Ezután meghatározhatjuk a beépülő modul megvalósítási osztályát:
implementációs osztály = org.gradle.GreetingPlugin
A megvalósítási osztály egyenlőnek kell lennie a plugin osztályunk teljes csomagnevével.
5.3. A Plugin ID létrehozása
Van néhány szabály és egyezmény, amelyet a plugin ID-nek be kell tartania a Gradle-ben. Legtöbbjük hasonló a Java csomagnév-szabályaihoz:
- Csak alfanumerikus karaktereket tartalmazhatnak, „.” és „-“
- Az azonosítónak rendelkeznie kell legalább egy „” jellel. elválasztva a domain nevet a beépülő modul nevétől
- Névterek org.gradle és com.gradleware korlátozottak
- Az azonosító nem kezdődhet és nem zárulhat „
- Nincs két vagy több egymást követő „.” karakterek megengedettek
Végül létezik egy olyan megállapodás, hogy a plug-id azonosítónak kisbetűnek kell lennie, amely követi a fordított domain név konvenciót.
A Java csomagnevek és a Gradle pluginnevek közötti fő különbség az, hogy a csomagnév általában részletesebb, mint a pluginazonosító.
5.4. Publishing Plugin
Amikor közzé akarjuk tenni a beépülő modulunkat, hogy külső projektekben is felhasználhassuk, kétféleképpen érhetjük el ezt.
Először, közzétehetjük a JAR pluginunkat egy külső tárolóban, mint például Maven vagy Borostyán.
Alternatív megoldásként használhatjuk a Gradle plugin portált. Ez lehetővé teszi pluginünk számára, hogy a Gradle közösség széles körben elérhető legyen. A projektek Gradle adattárban történő közzétételéről a Gradle Plugin Portal Documentation dokumentumban olvashat.
5.5. Java Gradle Development Plugin
Amikor a Java-ra írjuk a beépülő moduljainkat, profitálhatunk a Java Gradle Development Plugin.
Ez automatikusan lefordítja és hozzáadja gradleApi () függőségek. A plugin metaadatainak érvényesítését is elvégzi a gradle jar feladat.
Bővítményt hozzáadhatunk a következő blokk hozzáadásával a build szkriptünkhöz:
bővítmények {id 'java-gradle-plugin'}
6. A beépülő modulok tesztelése
Annak tesztelésére, hogy a bővítményünk megfelelően működik-e és megfelelően van-e alkalmazva a Projekt, tudjuk használni org.gradle.testfixtures.ProjectBuilder hogy létrehozzunk egy példányt a Projekt.
Ezután ellenőrizhetjük, hogy a beépülő modult alkalmazták-e, és hogy megfelelő feladatok vannak-e a programban Projekt példa. Használhatunk szabványt JUnit ennek elvégzésére szolgáló tesztek:
@Test public void greetingTest () {Project project = ProjectBuilder.builder (). Build (); project.getPluginManager (). Apply ("com.baeldung.greeting"); assertTrue (project.getPluginManager () .hasPlugin ("com.baeldung.greeting")); assertNotNull (project.getTasks (). getByName ("hello")); }
7. Összegzés
Ebben a cikkben bemutattuk az egyedi pluginek Gradle-ben történő írásának alapjait. A bővítménykészítés alaposabb megismeréséhez olvassa el a Gradle dokumentációt.
És mint mindig, az összes kódminta megtalálható a Githubon.
Következő » Zsíros edény létrehozása Gradle-ben « Előző Ant vs Maven vs Gradle