การสร้างโครงการหลายภาษา

A polyglot project is one that uses multiple programming languages. This isn't uncommon, especially in large systems or microservices architectures.

For example, you might have a backend service written in Java, a data processing component in Scala, and utility scripts in Groovy, all contributing to a single application.

Gradle excels at managing such diverse projects, allowing you to leverage the strengths of different languages within a unified build system.

Gradle achieves its polyglot capabilities through its powerful plugin system. Each language typically has a dedicated plugin that understands its compilation, testing, and packaging requirements.

These plugins integrate seamlessly, allowing Gradle to orchestrate builds involving Java, Groovy, Scala, Kotlin, and even native languages like C/C++ (via NDK for Android).

This means you can define dependencies and tasks across different language modules, all within a single Gradle build.

Groovy is a popular choice for scripting and enhancing Java projects. To include Groovy code, you typically apply the groovy plugin and place your source files in src/main/groovy.

Here's a minimal build.gradle for a Groovy project:

plugins {
  id 'groovy'
}

repositories {
  mavenCentral()
}

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

Now, let's see a simple Groovy program.

Scala is another powerful JVM language. Gradle supports Scala projects using the scala plugin. This plugin handles Scala compilation and integrates with Java source compilation.

To set up a Scala project, you'd apply the plugin and define Scala-specific dependencies, typically including the Scala library itself:

plugins {
  id 'scala'
}

repositories {
  mavenCentral()
}

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

Scala source files usually reside in src/main/scala.

With the scala plugin configured, Gradle can compile and run your Scala code. Here's a basic Scala program:

One of Gradle's strengths is allowing different JVM languages to coexist within the same project. You can have Java files in src/main/java and Scala files in src/main/scala.

Gradle's scala plugin automatically configures the build to compile both Java and Scala sources, ensuring they can call each other's code. This is crucial for migrating existing Java codebases or building complex polyglot applications.

The Java compiler runs first, then the Scala compiler, which can then see the compiled Java classes.

Android projects are prime examples of polyglot builds. They commonly involve Java, Kotlin, and sometimes even native C/C++ code (via the NDK).

The Android Gradle Plugin (AGP), applied via id 'com.android.application' or id 'com.android.library', is a sophisticated plugin that orchestrates the compilation, resource processing, and packaging for all these languages into an APK or AAR.

This allows developers to choose the best language for different parts of an Android app.

Kotlin is fully interoperable with Java and is another excellent choice for polyglot JVM projects. To include Kotlin, you apply the kotlin-jvm plugin and place source files in src/main/kotlin.

Here's a minimal build.gradle:

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

repositories {
  mavenCentral()
}

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

Let's run a simple Kotlin program.

In multi-project Gradle builds, you can define dependencies between subprojects written in different languages. For example, a Groovy subproject might depend on a Scala library subproject.

This is handled using standard Gradle project dependencies:

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

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

Gradle ensures that the dependent project (e.g., Scala) is built and compiled before the consuming project (e.g., Groovy).

Congratulations! You've explored how Gradle empowers you to manage polyglot projects, integrating multiple programming languages within a single build.

• Gradle's plugin system is key to its language-agnostic approach.
• You learned how to apply plugins for Groovy, Scala, and Kotlin.
• We discussed how different language sources can coexist and depend on each other.
• Android projects serve as a powerful example of real-world polyglot builds.

Mastering polyglot builds allows you to choose the best tool for each job, enhancing your project's flexibility and power. Keep experimenting with different language combinations!