Membangun Aplikasi Java Dengan Gradle

1. Gambaran keseluruhan

Tutorial ini memberikan panduan praktikal mengenai cara membina projek berasaskan Java menggunakan Gradle .

Kami akan menerangkan langkah-langkah membuat struktur projek secara manual, melakukan konfigurasi awal, dan menambahkan ketergantungan Java plug-in dan JUnit. Kemudian, kami akan membina dan menjalankan aplikasi.

Akhirnya, pada bahagian terakhir, kami akan memberikan contoh bagaimana melakukan ini dengan Gradle Build Init Plugin. Beberapa pengenalan asas juga boleh didapati dalam artikel Pengantar Gradle.

2. Struktur Projek Java

Sebelum kita membuat projek Java secara manual dan menyiapkannya untuk dibina, kita perlu memasang Gradle .

Mari mulakan membuat folder projek menggunakan konsol PowerShell dengan nama gradle-pegawai-aplikasi :

> mkdir gradle-employee-app

Selepas itu, mari kita pergi ke folder projek dan buat sub-folder:

> mkdir src/main/java/employee

Hasil yang dihasilkan ditunjukkan:

Directory: D:\gradle-employee-app\src\main\java Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2020 12:14 PM employee

Dalam struktur projek di atas, mari buat dua kelas. Salah satunya adalah kelas Pekerja sederhana dengan data seperti nama, alamat e-mel, dan tahun kelahiran:

public class Employee { String name; String emailAddress; int yearOfBirth; }

Yang kedua adalah kelas Aplikasi Pekerja utama yang mencetak data Pekerja :

public class EmployeeApp { public static void main(String[] args){ Employee employee = new Employee(); employee.name = "John"; employee.emailAddress = "[email protected]"; employee.yearOfBirth = 1978; System.out.println("Name: " + employee.name); System.out.println("Email Address: " + employee.emailAddress); System.out.println("Year Of Birth:" + employee.yearOfBirth); } }

3. Membina Projek Java

Seterusnya, untuk membina projek Java kami, kami membuat fail konfigurasi build.gradle dalam folder root projek .

Berikut ini adalah dalam baris arahan PowerShell:

Echo > build.gradle

Kami melangkau langkah seterusnya yang berkaitan dengan parameter input:

cmdlet Write-Output at command pipeline position 1 Supply values for the following parameters: InputObject[0]:

Untuk membina berjaya, kita perlu menambahkan Plugin Aplikasi :

plugins { id 'application' }

Kemudian, kami menggunakan pemalam aplikasi dan menambah nama kelas utama yang memenuhi syarat :

apply plugin: 'application' mainClassName = 'employee.EmployeeApp'

Setiap projek terdiri daripada tugas . Tugas mewakili karya yang dilakukan oleh binaan seperti menyusun kod sumber.

Sebagai contoh, kita dapat menambahkan tugas ke file konfigurasi yang mencetak pesan mengenai konfigurasi projek yang telah selesai:

println 'This is executed during configuration phase' task configured { println 'The project is configured' }

Biasanya, gradle build adalah tugas utama dan yang paling banyak digunakan. Tugas ini menyusun, menguji, dan mengumpulkan kod ke dalam fail JAR . Pembinaan dimulakan dengan menaip:

> gradle build 

Jalankan perintah di atas untuk mengeluarkan:

> Configure project : This is executed during configuration phase The project is configured BUILD SUCCESSFUL in 1s 2 actionable tasks: 2 up-to-date

Untuk melihat hasil build, mari kita lihat folder build yang mengandungi sub-folder: kelas, pengedaran, lib, dan laporan . Menaip Tree / F memberikan struktur folder build:

├───build │ ├───classes │ │ └───java │ │ ├───main │ │ │ └───employee │ │ │ Employee.class │ │ │ EmployeeApp.class │ │ │ │ │ └───test │ │ └───employee │ │ EmployeeAppTest.class │ │ │ ├───distributions │ │ gradle-employee-app.tar │ │ gradle-employee-app.zip │ ├───libs │ │ gradle-employee-app.jar │ │ │ ├───reports │ │ └───tests │ │ └───test │ │ │ index.html │ │ │ │ │ ├───classes │ │ │ employee.EmployeeAppTest.html

Seperti yang anda lihat, sub-folder kelas mengandungi dua fail .class yang dikompilasi yang kami buat sebelumnya. The pengagihan sub-folder mengandungi versi arkib pakej permohonan jar. Dan l IBS menyimpan fail balang permohonan kami.

Biasanya, dalam laporan , ada fail yang dihasilkan semasa menjalankan ujian JUnit.

Kini semuanya sudah siap untuk menjalankan projek Java dengan mengetik gradle run. Hasil pelaksanaan aplikasi semasa keluar:

> Configure project : This is executed during configuration phase The project is configured > Task :run Name: John Email Address: [email protected] Year Of Birth:1978 BUILD SUCCESSFUL in 1s 2 actionable tasks: 1 executed, 1 up-to-date 

3.1. Bangun Menggunakan Gradle Wrapper

Gradle Wrapper adalah skrip yang menggunakan versi Gradle yang dinyatakan .

Pertama, mari tentukan tugas pembungkus dalam fail build.gradle :

task wrapper(type: Wrapper){ gradleVersion = '5.3.1' }

Mari jalankan tugas ini menggunakan pembungkus gradle dari Power Shell:

> Configure project : This is executed during configuration phase The project is configured BUILD SUCCESSFUL in 1s 1 actionable task: 1 executed

Beberapa fail akan dibuat di bawah folder projek, termasuk fail di bawah / gradle / lokasi pembungkus :

│ gradlew │ gradlew.bat │ ├───gradle │ └───wrapper │ gradle-wrapper.jar │ gradle-wrapper.properties
  • gradlew : skrip shell yang digunakan untuk membuat tugas Gradle di Linux
  • gradlew.bat : skrip .bat yang digunakan oleh pengguna Windows untuk membuat tugas Gradle
  • gradle-wrapper.jar : balang aplikasi kami yang boleh dilaksanakan
  • gradle-wrapper.properties : fail sifat untuk mengkonfigurasi pembungkus

4. Add Java Dependencies and Run a Simple Test

First, in our configuration file, we need to set a remote repository from where we download dependency jars. Most often, these repositories are either mavenCentral() or jcenter(). Let's choose the second one:

repositories { jcenter() }

With our repositories created, we can then specify which dependencies to download. In this example, we are adding Apache Commons and JUnit library. To implement, add testImplementation and testRuntime parts in the dependencies configuration.

It builds on an additional test block:

dependencies { compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.10' testImplementation('junit:junit:4.13') testRuntime('junit:junit:4.13') } test { useJUnit() }

When that's done, let's try the work of JUnit on a simple test. Navigate to the src folder and make the sub-folders for the test:

src> mkdir test/java/employee

Within the last sub-folder, let's create EmployeeAppTest.java:

public class EmployeeAppTest { @Test public void testData() { Employee testEmp = this.getEmployeeTest(); assertEquals(testEmp.name, "John"); assertEquals(testEmp.emailAddress, "[email protected]"); assertEquals(testEmp.yearOfBirth, 1978); } private Employee getEmployeeTest() { Employee employee = new Employee(); employee.name = "John"; employee.emailAddress = "[email protected]"; employee.yearOfBirth = 1978; return employee; } }

Similar to before, let's run a gradle clean test from the command line and the test should pass without issue.

5. Java Project Initialization Using Gradle

In this section, we'll explain the steps for creating and building a Java application that we have gone through so far. The difference is that this time, we work with the help of the Gradle Build Init Plugin.

Create a new project folder and name it gradle-java-example. Then, switch to that empty project folder and run the init script:

> gradle init

Gradle will ask us with few questions and offer options for creating a project. The first question is what type of project we want to generate:

Select type of project to generate: 1: basic 2: cpp-application 3: cpp-library 4: groovy-application 5: groovy-library 6: java-application 7: java-library 8: kotlin-application 9: kotlin-library 10: scala-library Select build script DSL: 1: groovy 2: kotlin Enter selection [1..10] 6

Select option 6 for the type of project and then first option (groovy) for the build script.

Next, a list of questions appears:

Select test framework: 1: junit 2: testng 3: spock Enter selection (default: junit) [1..3] 1 Project name (default: gradle-java-example): Source package (default: gradle.java.example): employee BUILD SUCCESSFUL in 57m 45s 2 actionable tasks: 2 executed

Here, we select the first option, junit, for the test framework. Select the default name for our project and type “employee” as the name of the source package.

To see the complete directory structure within /src project folders, let's type Tree /F in Power Shell:

├───main │ ├───java │ │ └───employee │ │ App.java │ │ │ └───resources └───test ├───java │ └───employee │ AppTest.java │ └───resources

Finally, if we build the project with gradle run, we get “Hello World” on exit:

> Task :run Hello world. BUILD SUCCESSFUL in 1s 2 actionable tasks: 1 executed, 1 up-to-date

6. Conclusion

Dalam artikel ini, kami telah menyampaikan dua cara untuk membuat dan membangun aplikasi Java menggunakan Gradle. Hakikatnya, kami melakukan kerja manual dan kami mengambil masa untuk menyusun dan membina aplikasi dari baris perintah. Dalam kes ini, kita harus memperhatikan pengimportan beberapa pakej dan kelas yang diperlukan jika aplikasi menggunakan banyak perpustakaan.

Di sisi lain, skrip init Gradle mempunyai ciri yang menghasilkan kerangka ringan projek kami, serta beberapa fail konfigurasi yang berkaitan dengan Gradle .

Kod sumber untuk artikel ini terdapat di GitHub.