Egyéni Gradle bővítmények írása

Ez a cikk egy sorozat része: • Bevezetés a Gradle-be

• 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