Menulis Plugin Gradle Kustom

Artikel ini bagian dari serial: • Pengantar Gradle

• Semut vs Maven vs Gradle

• Menulis Plugin Gradle Kustom (artikel saat ini) • Membuat Fat Jar di Gradle

1. Perkenalan

Gradle adalah alat build yang sangat populer, yang sering dihargai karena proses build yang sangat dapat disesuaikan.

Hari ini kami akan menunjukkan cara membuat plugin Gradle kustom, yang memungkinkan kami memodifikasi proses build melebihi apa yang dapat kami capai dengan konfigurasi standar.

2. Lokasi Sumber Plugin

Kami dapat menempatkan kode kami di beberapa lokasi berbeda. Semuanya memiliki kelebihan dan kekurangan.

2.1. Build Script

Kita cukup meletakkan kode sumber plugin kita di dalam skrip build itu sendiri. Ini akan memberi kami kompilasi otomatis dan penyertaan plugin.

Ini sangat sederhana, namun, plugin kami tidak akan terlihat di luar skrip build. Karena itu, kami tidak dapat menggunakannya kembali di skrip build lain.

2.2. Folder BuildSrc

Kemungkinan lain yang bisa kita gunakan adalah menempatkan kode sumber plugin kita di folder buildSrc / src / main / java .

Saat Anda menjalankan Gradle, itu akan memeriksa keberadaan folder buildSrc . Jika ada, Gradle akan secara otomatis membuat dan menyertakan plugin kami.

Ini akan memberi kami kemungkinan untuk membagikan plugin kami di antara berbagai skrip build, tetapi kami masih tidak dapat menggunakannya di proyek lain.

2.3. Proyek Mandiri

Terakhir, kita dapat membuat plugin kita sebagai proyek terpisah yang membuat plugin dapat digunakan kembali sepenuhnya dalam berbagai proyek.

Namun, untuk menggunakannya dalam proyek eksternal, kita perlu memaketkannya dalam file jar dan menambahkannya ke proyek.

3. Plugin Pertama Kami

Mari kita mulai dengan dasar-dasarnya - setiap Plugin Gradle harus mengimplementasikan antarmuka com.gradle.api.Plugin .

Antarmukanya bersifat generik, jadi kita dapat melakukan parameter dengan berbagai jenis parameter. Biasanya, tipe parameternya adalah org.gradle.api.Project.

Namun, kita dapat menggunakan parameter tipe berbeda sehingga plugin diterapkan dalam fase masa hidup yang berbeda:

  • menggunakan org.gradle.api.Settings akan menghasilkan penerapan plugin ke skrip pengaturan
  • menggunakan org.gradle.api.Gradle akan menghasilkan penerapan plugin ke skrip inisialisasi

Plugin paling sederhana yang bisa kita buat adalah aplikasi hello world :

public class GreetingPlugin implements Plugin { @Override public void apply(Project project) { project.task("hello") .doLast(task -> System.out.println("Hello Gradle!")); } }

Sekarang kita dapat menerapkannya dengan menambahkan baris di dalam skrip build kita:

apply plugin: GreetingPlugin

Sekarang, setelah memanggil gradle hello, kita akan melihat pesan "Hello Gradle" di log.

4. Konfigurasi Plugin

Kebanyakan plugin memerlukan akses ke konfigurasi eksternal dari skrip build.

Kita dapat melakukannya dengan menggunakan objek ekstensi :

public class GreetingPluginExtension { private String greeter = "Baeldung"; private String message = "Message from the plugin!" // standard getters and setters }

Sekarang mari tambahkan objek ekstensi baru ke kelas plugin kita:

@Override public void apply(Project project) { GreetingPluginExtension extension = project.getExtensions() .create("greeting", GreetingPluginExtension.class); project.task("hello") .doLast(task -> { System.out.println( "Hello, " + extension.getGreeter()); System.out.println( "I have a message for You: " + extension.getMessage()); }); }

Sekarang, ketika kita memanggil gradle hello, kita akan melihat pesan default yang ditentukan di GreetingPluginExtension kita .

Tetapi karena kita telah membuat ekstensi, kita dapat menggunakan closure untuk melakukannya di dalam skrip build:

greeting { greeter = "Stranger" message = "Message from the build script" }

5. Proyek Plugin Standalone

For creating a standalone Gradle plugins, we need to do a little more work.

5.1. Setup

Firstly, we need to import the Gradle API dependency – which is quite straightforward:

dependencies { compile gradleApi() }

Note that doing the same in Maven requires gradle-tooling-api dependency – from the Gradle repository:

  org.gradle gradle-tooling-api 3.0   org.gradle gradle-core 3.0 provided     repo.gradle.org //repo.gradle.org/gradle/libs-releases-local/  

5.2. Wiring the Plugin

To allow Gradle to find the implementation of our standalone plugin, we need to create the properties file in the src/main/resources/META-INF/gradle-plugins.

The resource file needs to have a name that matches the plugin id. So if our plugin has an id of org.baeldung.greeting, the exact path of the file would be META-INF/gradle-plugins/org.baeldung.greeting.properties.

Next, we can define the implementation class of the plugin:

 implementation-class=org.gradle.GreetingPlugin

The implementation-class should be equal to the full package name of our plugin class.

5.3. Creating the Plugin ID

There are some rules and conventions that plugin ID must follow in Gradle. Most of them are similar to package name rules in Java:

  • They can contain only alphanumeric characters, “.” and “-“
  • The id has to have at least one “.” separating the domain name from the plugin name
  • Namespaces org.gradle and com.gradleware are restricted
  • An id cannot start or end with “.”
  • No two or more consecutive “.” characters are allowed

Finally, there's a convention that plugin Id should be a lower case name that follows reverse domain name convention.

The main difference between Java package names and Gradle plugin names is that the package name is usually more detailed than the plugin ID.

5.4. Publishing Plugin

When we want to publish our plugin to be able to reuse it in external projects, we have two ways of achieving that.

Firstly, we can publish our plugin JAR to an external repository like Maven or Ivy.

Alternatively, we can use the Gradle Plugin Portal. This will allow our plugin to be accessible by wide Gradle Community. More on publishing projects to Gradle repository can be found in Gradle Plugin Portal Documentation.

5.5. Java Gradle Development Plugin

When we're writing our plugins in Java, we can benefit from the Java Gradle Development Plugin.

This will automatically compile and add gradleApi() dependencies. It will also perform plugin metadata validation as a part of the gradle jar task.

We can add plugin by adding following block to our build script:

plugins { id 'java-gradle-plugin' }

6. Testing Plugins

To test that our plugin works properly and it's properly applied to the Project, we can use org.gradle.testfixtures.ProjectBuilder to create an instance of the Project.

We can then check if the plugin was applied and proper tasks are present in our Project instance. We can use standard JUnit tests to do that:

@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. Summary

Di artikel ini, kami telah menunjukkan dasar-dasar penulisan plugin kustom di Gradle. Untuk mempelajari lebih dalam tentang pembuatan plugin, lihat Dokumentasi Gradle.

Dan, seperti biasa, semua contoh kode dapat ditemukan di Github.

Berikutnya » Membuat Fat Jar di Gradle « Sebelumnya Ant vs Maven vs Gradle