gradle
ग्रेडल प्लगइन्स

`BuildSrc` से सरल प्रवण प्लगइन

एक सरल प्लगइन कैसे बनाएँ और अपने gradle प्रोजेक्ट के लिए DSL का सरल उदाहरण।
यह नमूना प्लगइन्स बनाने के तीन संभावित तरीकों में से एक का उपयोग करता है।
तीन तरीके हैं:

• पंक्ति में
• buildSrc
• स्टैंडअलोन प्लगइन्स

यह उदाहरण buildSrc फ़ोल्डर से एक प्लगइन बनाने से पता चलता है।

यह सैंपल पांच फाइलें बनाएगा

// 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 / ग्रूवी / तो / docs / Gradle / प्लगइन / 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 / मुख्य / ग्रूवी / तो / docs / Gradle / प्लगइन / 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 / मुख्य / संसाधन / META-INF / Gradle-plugins / sample.properties

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

इस सेटअप का उपयोग करके हम आपके DSL ब्लॉक में कॉलर द्वारा दिए गए मूल्यों को देख सकते हैं

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

कैसे एक स्टैंडअलोन प्लगइन लिखने के लिए

एक कस्टम स्टैंडअलोन ग्रेडल प्लग-इन जावा (आप ग्रूवी का उपयोग भी कर सकते हैं) बनाने के लिए आपको एक संरचना बनाना होगा जैसे:

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

सेटअप ग्रेडल कॉन्फ़िगरेशन

build.gradle फ़ाइल में आप अपनी परियोजना को परिभाषित करते हैं।

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

dependencies {
    compile gradleApi()
} 

जावा कोड लिखने के लिए java plugin का उपयोग किया जाएगा।
gradleApi() निर्भरता हमें एक ग्रेड प्लगइन बनाने के लिए आवश्यक सभी विधि और gradleApi() प्रदान करेगी।

settings.gradle फ़ाइल को settings.gradle :

rootProject.name = 'myplugin' 

यह मावेन में विरूपण साक्ष्य आईडी को परिभाषित करेगा।
यदि settings.gradle फ़ाइल प्लगइन निर्देशिका में मौजूद नहीं है, तो डिफ़ॉल्ट मान निर्देशिका का नाम होगा।

प्लगइन बनाएँ

एक वर्ग को परिभाषित करें src/main/java/org/sample/MyPlugin.java 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);
    }

} 

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");
    }
}

प्लगइन वर्ग की घोषणा

META-INF/gradle-plugins फ़ोल्डर में आपको implementation-class संपत्ति को परिभाषित करने वाली एक गुण फ़ाइल तैयार करनी होगी जो प्लगइन कार्यान्वयन वर्ग की पहचान करती है।

META-INF/gradle-plugins/testplugin.properties

implementation-class=org.sample.MyPlugin.java

ध्यान दें कि गुण फ़ाइल नाम प्लगइन आईडी से मेल खाता है ।

इसे कैसे बनाएं और प्रकाशित करें

build.gradle रेपो में प्लगइन अपलोड करने के लिए कुछ जानकारी जोड़कर build.gradle फ़ाइल बदलें:

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

dependencies {
    compile gradleApi()
}

repositories {
    jcenter()
}


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

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

आप निम्न आदेश का उपयोग करके plugin/build.gradle फ़ाइल में परिभाषित मावेन रेपो में plugin/build.gradle प्लग-इन का निर्माण और प्रकाशन कर सकते हैं।

$ ./gradlew clean uploadArchives 

इसका इस्तेमाल कैसे करें

अपनी परियोजना के build.gradle में प्लगइन ऐड का उपयोग करने के लिए:

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

तब आप कार्य का उपयोग करके कॉल कर सकते हैं:

 $ ./gradlew myTask