Binaan Projek Poliglot

Projek poliglot ialah projek yang menggunakan berbilang bahasa pengaturcaraan. Perkara ini tidak luar biasa, khususnya dalam sistem besar atau seni bina perkhidmatan mikro.

Contohnya, anda mungkin mempunyai perkhidmatan bahagian belakang yang ditulis dalam Java, komponen pemprosesan data dalam Scala dan skrip utiliti dalam Groovy, yang semuanya menyumbang kepada satu aplikasi.

Gradle cemerlang dalam mengurus projek yang pelbagai ini, membolehkan anda memanfaatkan kekuatan bahasa yang berbeza dalam sistem binaan yang bersatu.

Gradle mencapai keupayaan poliglotnya melalui sistem plugin yang berkuasa. Setiap bahasa biasanya mempunyai plugin khusus yang memahami keperluan penyusunan, pengujian dan pembungkusannya.

Plugin ini bersepadu dengan lancar, membolehkan Gradle mengatur binaan yang melibatkan Java, Groovy, Scala, Kotlin dan juga bahasa natif seperti C/C++ (melalui NDK untuk Android).

Ini bermakna anda boleh mentakrifkan kebergantungan dan tugasan merentas modul bahasa yang berbeza, semuanya dalam satu binaan Gradle.

Groovy ialah pilihan popular untuk penskripan dan mempertingkat projek Java. Untuk memasukkan kod Groovy, anda biasanya menggunakan plugin groovy dan meletakkan fail sumber anda dalam src/main/groovy.

Berikut ialah build.gradle minimum untuk projek Groovy:

plugins {
  id 'groovy'
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'org.codehaus.groovy:groovy-all:3.0.9'
}

Sekarang, mari lihat program Groovy yang ringkas.

Scala ialah satu lagi bahasa JVM yang berkuasa. Gradle menyokong projek Scala menggunakan pemalam scala. Pemalam ini mengendalikan penyusunan Scala dan berintegrasi dengan penyusunan kod sumber Java.

Untuk menyediakan projek Scala, anda perlu menggunakan pemalam tersebut dan mentakrifkan kebergantungan khusus Scala, biasanya termasuk pustaka Scala itu sendiri:

plugins {
  id 'scala'
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'org.scala-lang:scala-library:2.13.6'
  // If mixing with Java, add Java dependencies here too
}

Fail sumber Scala biasanya terletak dalam src/main/scala.

Dengan pemalam scala yang telah dikonfigurasi, Gradle boleh menyusun dan menjalankan kod Scala anda. Berikut ialah program Scala asas:

Salah satu kelebihan Gradle ialah membenarkan bahasa JVM yang berbeza wujud bersama dalam projek yang sama. Anda boleh mempunyai fail Java dalam src/main/java dan fail Scala dalam src/main/scala.

Pemalam scala Gradle mengkonfigurasi binaan secara automatik untuk menyusun sumber Java dan Scala, serta memastikan kedua-duanya boleh memanggil kod satu sama lain. Ini penting untuk memindahkan asas kod Java sedia ada atau membina aplikasi poliglot yang kompleks.

Penyusun Java berjalan dahulu, kemudian penyusun Scala, yang kemudiannya boleh melihat kelas Java yang telah disusun.

Projek Android ialah contoh utama binaan poliglot. Projek ini biasanya melibatkan Java, Kotlin dan kadangkala kod C/C++ asli juga (melalui NDK).

Pemalam Android Gradle (AGP), yang digunakan melalui id 'com.android.application' atau id 'com.android.library', ialah pemalam canggih yang menyelaraskan penyusunan, pemprosesan sumber dan pembungkusan semua bahasa ini menjadi APK atau AAR.

Hal ini membolehkan pembangun memilih bahasa terbaik untuk bahagian aplikasi Android yang berbeza.

Kotlin serasi sepenuhnya dengan Java dan merupakan satu lagi pilihan yang sangat baik untuk projek JVM poliglot. Untuk menyertakan Kotlin, gunakan pemalam kotlin-jvm dan letakkan fail sumber dalam src/main/kotlin.

Berikut ialah build.gradle minimum:

plugins {
  id 'org.jetbrains.kotlin.jvm' version '1.9.0' // Use a recent version
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'org.jetbrains.kotlin:kotlin-stdlib'
}

Mari jalankan program Kotlin yang ringkas.

Dalam binaan Gradle berbilang projek, anda boleh mentakrifkan kebergantungan antara subprojek yang ditulis dalam bahasa berbeza. Contohnya, subprojek Groovy mungkin bergantung pada subprojek pustaka Scala.

Hal ini dikendalikan menggunakan kebergantungan projek Gradle standard:

// In settings.gradle
include 'my-scala-lib', 'my-groovy-app'

// In my-groovy-app/build.gradle
dependencies {
  implementation project(':my-scala-lib')
}

Gradle memastikan projek yang menjadi kebergantungan (contohnya, Scala) dibina dan disusun sebelum projek yang menggunakannya (contohnya, Groovy).

Tahniah! Anda telah meneroka cara Gradle membantu anda mengurus projek poliglot dengan mengintegrasikan berbilang bahasa pengaturcaraan dalam satu binaan.

• Sistem pemalam Gradle ialah kunci kepada pendekatannya yang tidak bergantung pada bahasa.
• Anda telah mempelajari cara menggunakan pemalam untuk Groovy, Scala dan Kotlin.
• Kita telah membincangkan cara sumber daripada bahasa yang berbeza boleh wujud bersama dan saling bergantung.
• Projek Android menjadi contoh berkuasa bagi binaan poliglot dunia sebenar.

Menguasai binaan poliglot membolehkan anda memilih alat terbaik untuk setiap tugas, sekali gus meningkatkan fleksibiliti dan keupayaan projek anda. Teruskan bereksperimen dengan gabungan bahasa yang berbeza!