gradle
Gradle Plugins

Simple plugin de gradule de `buildSrc`

Exemple simple de création d'un plugin personnalisé et de DSL pour votre projet de graduation.
Cet exemple utilise l'une des trois manières possibles de créer des plug-ins.
Les trois manières sont:

• en ligne
• buildSrc
• plugins autonomes

Cet exemple montre comment créer un plug-in à partir du dossier buildSrc .

Cet exemple va créer cinq fichiers

// 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

En utilisant cette configuration, nous pouvons voir les valeurs fournies par l'appelant dans votre bloc DSL

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

Comment écrire un plugin autonome

Pour créer un plug-in Gradle autonome personnalisé avec java (vous pouvez également utiliser Groovy), vous devez créer une structure comme celle-ci:

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

Configuration de la configuration progressive

Dans le fichier build.gradle , vous définissez votre projet.

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

dependencies {
    compile gradleApi()
} 

Le plugin java sera utilisé pour écrire du code Java.
La dépendance gradleApi() nous donnera toutes les méthodes et propriétés nécessaires pour créer un plugin Gradle.

Dans le fichier settings.gradle :

rootProject.name = 'myplugin' 

Il définira l' identifiant de l' artefact dans Maven.
Si le fichier settings.gradle n'est pas présent dans le répertoire du plugin, la valeur par défaut sera le nom du répertoire.

Créer le plugin

Définissez une classe dans src/main/java/org/sample/MyPlugin.java implémentant l'interface du 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);
    }

} 

Définissez la tâche étendant la classe 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");
    }
}

Déclaration de classe de plugin

Dans le dossier META-INF/gradle-plugins , vous devez créer un fichier de propriétés définissant la propriété de implementation-class qui identifie la classe d'implémentation du plug META-INF/gradle-plugins .

Dans le META-INF/gradle-plugins/testplugin.properties

implementation-class=org.sample.MyPlugin.java

Notez que le nom du fichier de propriétés correspond à l'ID du plug-in .

Comment le construire et le publier

Modifiez le fichier build.gradle en ajoutant des informations pour télécharger le plug-in dans un dépôt 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)
        }
    }
} 

Vous pouvez créer et publier le plug-in Gradle sur le plugin/build.gradle Maven défini dans le fichier plugin/build.gradle à l'aide de la commande suivante.

$ ./gradlew clean uploadArchives 

Comment l'utiliser

Pour utiliser le plug-in ajouter dans le build.gradle de votre projet:

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

Ensuite, vous pouvez appeler la tâche en utilisant:

 $ ./gradlew myTask