Menulis Plugin Gradle Khusus

Artikel ini adalah sebahagian daripada siri: • Pengenalan kepada Gradle

• Semut vs Maven vs Gradle

• Menulis Plugin Gradle Khusus (artikel semasa) • Membuat Jar Lemak di Gradle

1. Pengenalan

Gradle adalah alat binaan yang sangat popular, yang sering dihargai untuk proses binaan yang sangat disesuaikan.

Hari ini kita akan menunjukkan cara membuat plugin Gradle tersuai, yang akan membolehkan kita mengubah proses membina melebihi apa yang dapat kita capai dengan konfigurasi standard.

2. Lokasi Sumber Plugin

Kami boleh meletakkan kod kami di beberapa lokasi yang berbeza. Kesemuanya mempunyai beberapa kelebihan dan kekurangan.

2.1. Bina Skrip

Kita hanya boleh memasukkan kod sumber plugin kita ke dalam skrip binaan itu sendiri. Ini akan memberi kita penyusunan automatik dan penyertaan pemalam.

Sangat mudah, namun plugin kami tidak akan kelihatan di luar skrip binaan. Oleh kerana itu, kami tidak dapat menggunakannya kembali dalam skrip binaan lain.

2.2. Folder BuildSrc

Kemungkinan lain yang dapat kita gunakan adalah meletakkan kod sumber plugin kita di folder buildSrc / src / main / java .

Semasa anda menjalankan Gradle, ia akan memeriksa keberadaan folder buildSrc . Sekiranya ada, Gradle akan membina dan memasukkan pemalam kami secara automatik.

Ini akan memberi kita kemungkinan untuk berkongsi plugin antara pelbagai skrip binaan, tetapi kita masih tidak dapat menggunakannya dalam projek lain.

2.3. Projek Berdiri

Akhirnya, kita dapat membuat plugin kita sebagai projek yang berasingan yang menjadikan plugin dapat digunakan semula dalam pelbagai projek.

Walau bagaimanapun, untuk menggunakannya dalam projek luaran, kita perlu menggabungkannya dalam fail balang dan menambahkannya ke projek.

3. Pemalam Pertama Kami

Mari kita mulakan dengan asas - setiap Gradle Plugin mesti melaksanakan antara muka com.gradle.api.Plugin .

Antaramuka bersifat generik, jadi kami dapat memisahkannya dengan pelbagai jenis parameter. Biasanya, jenis parameter adalah org.gradle.api.Project.

Namun, kami dapat menggunakan parameter jenis yang berlainan sehingga plugin diterapkan dalam fasa jangka hayat yang berbeza:

  • menggunakan org.gradle.api.Setting akan menghasilkan penerapan plugin ke skrip tetapan
  • menggunakan org.gradle.api.Gradle akan menghasilkan pemalam pada skrip permulaan

Plugin termudah yang boleh kami 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!")); } }

Kami sekarang dapat menerapkannya dengan menambahkan garis di dalam skrip binaan kami:

apply plugin: GreetingPlugin

Sekarang, setelah memanggil gradle hello, kita akan melihat mesej "Hello Gradle" dalam log.

4. Konfigurasi Plugin

Sebilangan besar pemalam memerlukan akses ke konfigurasi luaran dari skrip binaan.

Kita boleh melakukannya dengan menggunakan objek lanjutan :

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

Mari sekarang tambahkan objek pelanjutan baru ke kelas pemalam kami:

@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, apabila kita memanggil gradle hello, kita akan melihat mesej lalai yang ditentukan dalam GreetingPluginExtension kami .

Tetapi kerana kami telah membuat peluasan, kami dapat menggunakan penutupan untuk melakukannya di dalam skrip build:

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

5. Projek Plugin Berdiri

Untuk membuat plugin Gradle yang berdiri sendiri, kita perlu melakukan lebih banyak kerja.

5.1. Persediaan

Pertama, kita perlu mengimport kebergantungan Gradle API - yang cukup mudah:

dependencies { compile gradleApi() }

Perhatikan bahawa melakukan perkara yang sama di Maven memerlukan pergantungan gradle-tooling-api - dari repositori Gradle:

  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. Pendawaian Pemalam

Untuk membolehkan Gradle mencari pelaksanaan plugin mandiri kami, kami perlu membuat fail sifat dalam plugin src / main / resources / META-INF / gradle -plugins .

Fail sumber mesti mempunyai nama yang sepadan dengan id pemalam. Oleh itu, jika pemalam kami mempunyai id org.baeldung.greeting, jalan yang tepat dari fail tersebut adalah 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

Dalam artikel ini, kami telah menunjukkan asas menulis plugin tersuai di Gradle. Untuk mengetahui lebih mendalam mengenai pembuatan plugin, lihat Gradle Documentation.

Seperti biasa, semua contoh kod boleh didapati di Github.

Seterusnya » Membuat Jar Lemak di Gradle « Semut sebelumnya vs Maven vs Gradle