ปลั๊กอินตามแบบแผนและตรรกะการสร้าง

In large Gradle multi-project builds, maintaining consistent configurations across many subprojects can become a challenge. This is where Convention Plugins come in handy.

A convention plugin is essentially a way to package and reuse common build logic and configurations specific to your organization or project. They help enforce standards and reduce boilerplate.

Imagine you have several Java subprojects. Each needs to apply the java-library plugin, set a specific Java toolchain, and configure common repositories. Without convention plugins, you might end up with repetitive and slightly different configurations in each build.gradle file.

To solve the problem of repetition, Gradle offers a special directory: buildSrc. When present in your project root, Gradle automatically compiles any code (Groovy, Kotlin, Java) found within buildSrc and adds it to the classpath of your build scripts.

This makes buildSrc the perfect place to define internal build logic, custom tasks, and especially, convention plugins.

Let's create a simple convention plugin to standardize our Java library setup. We'll define it in buildSrc/src/main/groovy/my.java-conventions.groovy. This plugin will apply the java-library plugin, set Java 17 as the toolchain, and add mavenCentral().

Once you've defined your convention plugin in buildSrc, you can apply it to any subproject's build.gradle file using its ID. Notice how much cleaner and more concise the subproject's build file becomes!

Convention plugins can do much more than just basic settings. You can enforce common dependencies, configure testing frameworks, or standardize other build aspects. Here, we add JUnit Jupiter dependencies and a common test logging configuration.

Just like regular build scripts, convention plugins can also be written using the Kotlin DSL (.gradle.kts files). This provides compile-time safety and better IDE support, which can be very valuable for complex build logic.

The structure remains similar, just with Kotlin syntax.

While convention plugins are often used for subprojects, they can also be applied to the root project's build.gradle. This is useful for defining build-wide properties or configurations that should apply to the entire project, like common dependency versions.

Convention plugins are a cornerstone of maintainable, large-scale Gradle builds:

• Consistency: Ensures all projects adhere to organizational standards.
• Reduced Duplication: Centralizes common build logic, eliminating copy-pasting.
• Easier Maintenance: Update standards in one place; all projects instantly benefit.
• Improved Readability: Subproject build files become shorter and more focused on project-specific details.

When creating them, keep plugins focused on a single concern, use clear IDs, and leverage Kotlin DSL for type safety.

You've now learned about Gradle Convention Plugins! They are an essential tool for managing complex, multi-project builds.

• Convention plugins centralize common build logic.
• They are typically defined in the buildSrc directory.
• They help enforce consistent configurations (Java versions, dependencies, test setups).
• They drastically reduce boilerplate and improve maintainability.

By leveraging convention plugins, you can build more robust and scalable Gradle projects.