การใช้และเผยแพร่ปลั๊กอิน

So you've learned to create custom Gradle plugins. Great! But how do you actually use them in different projects, and how can you share them with others?

This lesson explores how to apply your custom plugins to a Gradle project and how to publish them to a local or remote repository for wider use.

Before diving into custom plugins, let's quickly recall how you apply standard plugins.

• Most plugins are applied using the plugins { id 'plugin-id' } block in your build.gradle file.
• This method is preferred for its declarative nature and better tooling support.
• It works for plugins from Gradle Plugin Portal, local buildSrc plugins, and published plugins.

You can define build logic directly within your build.gradle or include it from another script. This is the simplest form of reusing logic.

Below, a custom task myCustomTask is defined. It's available to your build script just like any other task.

For more complex, project-specific plugins, Gradle automatically compiles and makes available any plugins defined in the buildSrc directory.

If you create a plugin in buildSrc/src/main/groovy/com/example/MyPlugin.groovy, it can be applied directly by its ID:

• Define plugin: buildSrc/src/main/groovy/my.project.plugin.gradle
• Apply plugin: plugins { id 'my.project.plugin' }

Gradle ensures buildSrc is built before your main project, making its plugins ready for use.

While buildSrc is great for single-project or monorepo plugins, what if you want to share your plugin across completely separate projects, or even with the community?

This is where publishing comes in. Publishing makes your plugin available in a repository, just like any other library you use (e.g., from Maven Central).

• Local: Share within your machine for personal use.
• Remote: Share within your organization (Artifactory, Nexus) or globally (Gradle Plugin Portal, Maven Central).

Gradle's maven-publish plugin is the standard way to publish your plugin artifacts to Maven-compatible repositories.

By applying this plugin, you gain access to a publishing block in your build.gradle, where you'll define the details of what gets published and how.

It also introduces tasks like publishToMavenLocal and publish.

Inside the publishing block, you configure the details of your artifact: its name, what components to include (like JARs), and where it should go.

A "publication" defines a set of artifacts and their metadata (group, artifact ID, version).

After configuring your publication, you can publish your plugin to your local Maven repository. This is great for local testing and development.

Gradle provides a task for each publication you define (e.g., publishMavenPublicationToMavenLocal if your publication is named maven).

To use a plugin you've published to mavenLocal() in another project, you need two things:

1. Declare mavenLocal(): Add mavenLocal() to the pluginManagement.repositories block in your consuming project's settings.gradle.
2. Apply by ID and Version: Use the plugins { id '...' version '...' } block in your consuming project's build.gradle.

This tells Gradle to look for the plugin in your local Maven repository.

To share your plugin beyond your local machine, you publish it to a remote repository. This could be:

• Company Artifactory/Nexus: For internal team use.
• Gradle Plugin Portal: For public plugins, requiring the com.gradle.plugin-publish plugin.
• Maven Central: The largest public repository.

The configuration in the publishing.repositories block specifies the URL and credentials for these remote destinations.

Time to test your understanding of applying and publishing plugins.

You've learned how to make your custom Gradle plugins truly reusable!

• You can apply simple script plugins using apply from:.
• Plugins in buildSrc are automatically available by ID.
• The maven-publish plugin allows you to define and publish your plugin artifacts.
• Publishing to mavenLocal() is great for local testing.
• To use a published plugin, configure mavenLocal() in settings.gradle and apply it by ID and version.
• Remote repositories enable sharing plugins across teams or publicly.

Now you can build powerful, shareable build logic!