gradle
Plugins Gradle

Plugin simple de Gradle de `buildSrc`

Ejemplo simple de cómo crear un complemento personalizado y DSL para su proyecto de Gradle.
Esta muestra utiliza una de las tres formas posibles de crear complementos.
Las tres formas son:

• en línea
• buildSrc
• complementos independientes

Este ejemplo muestra la creación de un complemento desde la carpeta buildSrc .

Esta muestra creará cinco archivos.

// project's build.gradle
build.gradle
// build.gradle to build the `buildSrc` module
buildSrc/build.gradle
// file name will be the plugin name used in the `apply plugin: $name`
// where name would be `sample` in this example
buildSrc/src/main/resources/META-INF/gradle-plugins/sample.properties
// our DSL (Domain Specific Language) model
buildSrc/src/main/groovy/so/docs/gradle/plugin/SampleModel.groovy
// our actual plugin that will read the values from the DSL
buildSrc/src/main/groovy/so/docs/gradle/plugin/SamplePlugin.groovy

build.gradle:

group 'so.docs.gradle'
version '1.0-SNAPSHOT'

apply plugin: 'groovy'
// apply our plugin... calls SamplePlugin#apply(Project)
apply plugin: 'sample'

repositories {
    mavenCentral()
}

dependencies {
    compile localGroovy()
}

// caller populates the extension model applied above
sample {
    product = 'abc'
    customer = 'zyx'
}

// dummy task to limit console output for example
task doNothing <<{}

buildSrc / build.gradle

apply plugin: 'groovy'

repositories {
    mavenCentral()
}

dependencies {
    compile localGroovy()
}

buildSrc / src / main / groovy / so / docs / gradle / plugin / SamplePlugin.groovy

package so.docs.gradle.plugin

import org.gradle.api.Plugin
import org.gradle.api.Project

class SamplePlugin implements Plugin<Project> {
    @Override
    void apply(Project target) {
        // create our extension on the project for our model
        target.extensions.create('sample', SampleModel)
        // once the script has been evaluated the values are available
        target.afterEvaluate {
            // here we can do whatever we need to with our values
            println "populated model: $target.extensions.sample"
        }
    }
}

buildSrc / src / main / groovy / so / docs / gradle / plugin / SampleModel.groovy:

package so.docs.gradle.plugin

// define our DSL model
class SampleModel {
    public String product;
    public String customer;

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("SampleModel{");
        sb.append("product='").append(product).append('\'');
        sb.append(", customer='").append(customer).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

buildSrc / src / main / resources / META-INF / gradle-plugins / sample.properties

implementation-class=so.docs.gradle.plugin.SamplePlugin

Usando esta configuración podemos ver los valores proporcionados por la persona que llama en su bloque DSL

 $ ./gradlew -q doNothing
SampleModel{product='abc', customer='zyx'}

Cómo escribir un plugin independiente

Para crear un complemento Gradle independiente personalizado utilizando java (también puede usar Groovy), debe crear una estructura como esta:

plugin
|-- build.gradle
|-- settings.gradle
|-- src
    |-- main
    |   |-- java
    |   |-- resources
    |       |-- META-INF
    |           |-- gradle-plugins
    |-- test

Configurar la configuración de Gradle

En el archivo build.gradle usted define su proyecto.

apply plugin: 'java'
apply plugin: 'maven'

dependencies {
    compile gradleApi()
} 

El complemento java se utilizará para escribir código java.
La dependencia gradleApi() nos dará todos los métodos y propiedades necesarios para crear un complemento de Gradle.

En el archivo settings.gradle :

rootProject.name = 'myplugin' 

Definirá la identificación del artefacto en Maven.
Si el archivo settings.gradle no está presente en el directorio del complemento, el valor predeterminado será el nombre del directorio.

Crear el plugin

Defina una clase en el src/main/java/org/sample/MyPlugin.java implementando la interfaz del Plugin .

import org.gradle.api.Plugin;
import org.gradle.api.Project;

public class MyPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {
         project.getTasks().create("myTask", MyTask.class);
    }

} 

Defina la tarea extendiendo la clase DefaultTask :

import org.gradle.api.DefaultTask;
import org.gradle.api.tasks.TaskAction;

public class MyTask extends DefaultTask {

    @TaskAction
    public void myTask() {
        System.out.println("Hello World");
    }
}

Declaración de clase de plugin

En la carpeta META-INF/gradle-plugins , debe crear un archivo de propiedades que defina la propiedad de implementation-class que identifica la clase de implementación de complemento.

En el META-INF/gradle-plugins/testplugin.properties

implementation-class=org.sample.MyPlugin.java

Observe que el nombre de archivo de las propiedades coincide con el ID del complemento .

Cómo construirlo y publicarlo.

Cambie el archivo build.gradle agregando información para cargar el complemento en un repositorio de Maven:

apply plugin: 'java'
apply plugin: 'maven'

dependencies {
    compile gradleApi()
}

repositories {
    jcenter()
}


group = 'org.sample'
version = '1.0'

uploadArchives {
    repositories {
        mavenDeployer {
        repository(url: mavenLocal().url)
        }
    }
} 

Puede compilar y publicar el complemento de Gradle en el repositorio de Maven definido en el archivo plugin/build.gradle usando el siguiente comando.

$ ./gradlew clean uploadArchives 

Cómo usarlo

Para usar el complemento, agregue en el build.gradle de su proyecto:

buildscript {
     repositories {
         mavenLocal()
     }
 dependencies {
    classpath group: 'org.sample',    // Defined in the build.gradle of the plugin
              name: 'myplugin',       // Defined by the rootProject.name 
              version: '1.0'
    }
 }

apply plugin: 'testplugin'            // Defined by the properties filename

Luego puedes llamar a la tarea usando:

 $ ./gradlew myTask