Überblick

Startete eine neue Serie, diese Serie des Lernens von Gradle. Das Ziel ist es, Gradle gründlich zu verstehen, hauptsächlich Notizen zu machen, die Sie verstehen, um das Vergessen zu verhindern

Einführung

Gradle selbst bietet nur grundlegende Kernfunktionen, und andere Funktionen wie die Fähigkeit zum Kompilieren von Java-Quellcode, die Fähigkeit zum Kompilieren von Android-Projekten usw. müssen über Plug-Ins implementiert werden.
Um Plug-Ins verwenden zu können, müssen Sie die Anwendung über Anwendungs-Plug-Ins Project.apply()in das Projekt einbinden , um die Methode abzuschließen.
In Gradle gibt es im Allgemeinen zwei Arten von Plug-Ins: 脚本插件und 对象插件.

脚本插件Es ist ein zusätzliches Build-Skript, das den Build weiter konfiguriert, was als normales build.gradle verstanden werden kann.

对象插件Diese Klasse wird auch als binäres Plug-In bezeichnet und implementiert die Plugin-Schnittstelle. Im Folgenden wird ihre Verwendung beschrieben.

Skript-Plugin

Zum Beispiel erstellen wir eine im Stammverzeichnis des Projektsutils.gradle

def getxmlpackage(boolean x){
    
    
    def file=new File(project.getProjectDir().getPath()+"/src/main/AndroidManifest.xml");
    def paser = new XmlParser().parse(file)
    return paser.@package
}

ext{
    
    
    getpackage = this.&getxmlpackage
}

Dies ist ein einfaches Skript-Plugin, und verweisen Sie dann auf dieses Skript-Plugin im App-Moudle

apply from: rootProject.getRootDir().getAbsolutePath() + "/utils.gradle"

Anschließend können Sie die Methode im Skript-Plugin aufrufen

Objekt-Plugin

Objekt-Plug-Ins sind Plug-Ins, die die Schnittstelle org.gradle.api.plugins implementieren. Objekt-Plug-Ins können in interne Plug-Ins und Plug-Ins von Drittanbietern unterteilt werden.

Internes Plugin

Das Gradle-Paket enthält eine große Anzahl von Plugins, z. B. die Java-Plugins und C-Plugins, die wir häufig verwenden. Wir können sie direkt importieren

apply plugin:'java'
apply plugin:'cpp'

Drei-Parteien-Plug-In

Das Objekt-Plug-In eines Drittanbieters ist normalerweise eine JAR-Datei. Wenn das Build-Skript die Existenz des Plug-Ins eines Drittanbieters kennen soll, müssen Sie Buildscrip verwenden, um es festzulegen.
Definieren Sie das ursprüngliche Warehouse, in dem sich das Plugin befindet, und die Abhängigkeiten des Plugins in Buildscrip und konfigurieren Sie es anschließend mit der Methode apply. Das Android Gradle-Plugin ist auch ein Plugin eines Drittanbieters. Wenn wir das Android Gradle-Plugin einführen möchten, können wir schreiben:

buildscript {
    
    
    repositories {
    
    
    	//配置仓库
        google()
        jcenter()
    }
    dependencies {
    
    
    	//配置插件依赖
        classpath 'com.android.tools.build:gradle:3.5.3'
    }
}
//然后就可以在需要的地方引入android 插件了
apply plugin: 'com.android.application'

Benutzerdefiniertes Objekt-Plugin

Das Anpassen eines Plug-Ins dient hauptsächlich der Implementierung von org.gradle.api.Plugin

Skript erstellen

Diese Methode schreibt den Plug-In-Code direkt in das Build-Skript. Diese Methode kann jedoch nur in dieser Datei verwendet werden. Ich füge beispielsweise den folgenden Code direkt in das build.gradle der App ein

class myPlugin implements Plugin<Project>{
    
    
    @Override
    void apply(Project project) {
    
    
        println("myPlugin 执行了")

        project.task("myTask"){
    
    
            doLast {
    
    
                println("myTask执行了")
            }
        }
    }
}

Importieren Sie dann das in dieser Datei definierte Plugin

apply plugin: myPlugin

Dies dient dazu, ein Plug-In direkt in build.gradle zu implementieren und eine MyTaskAufgabe im Plug-In zu definieren . Dieses Plug-In kann jedoch nur in dieser Datei verwendet werden. Wir führen die MytaskAufgabe direkt aus./gradlew MyTask

> Task :mylibrary2:myTask
myTask执行了
执行阶段，task ':mylibrary2:myTask'耗时：1ms

Wir verwenden die auf diese Weise implementierten Plug-Ins im Allgemeinen nicht, da diese zu restriktiv ist und nur in diesem Projekt verwendet werden kann, nicht jedoch in anderen Projekten.

buildSrc-Projekt

buildSrc ist das Standard-Plug-In-Verzeichnis von Gradle. Dieses Verzeichnis wird automatisch erkannt, wenn Gradle kompiliert wird, und der darin enthaltene Code wird in ein Plug-In kompiliert.

Erst erst ein benanntes buildSrcJava-Modul erstellen , dann nur behalten build.gradleund das src/mainVerzeichnis, alle anderen löschen, auf den Namen achten muss sein buildSrc, sonst wird das Plug-In nicht gefunden
Ändern Sie dann den Inhalt in Gradle

apply plugin: 'groovy'  //必须
apply plugin: 'maven'

dependencies {
    
    
    implementation gradleApi() //必须
    implementation localGroovy() //必须
    //如果要使用android的API，需要引用这个，实现Transform的时候会用到
    //implementation 'com.android.tools.build:gradle:3.3.0'
}

repositories {
    
    
    google()
    jcenter()
    mavenCentral() //必须
}

//把项目入口设置为src/main/groovy
sourceSets {
    
    
    main {
    
    
        groovy {
    
    
            srcDir 'src/main/groovy'
        }
    }
}

Erstellen Sie ein Eintragsverzeichnis, erstellen Sie ein Code-Eingabeverzeichnis unter src / main wie folgt:
Implementieren Sie dann den Plug-In-Code Text.groovy, achten Sie auf das Dateisuffix groovy, die Datei sollte importiert werdenpackage com.renxh

package com.renxh

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

class Text implements Plugin<Project>{
    
    
    @Override
    void apply(Project project) {
    
    
        println("执行自定义插件")
        project.task("haha"){
    
    
            doLast{
    
    
                println("执行自定义插件 haha task")
            }
        }
    }
}

mainErstellen Sie als Nächstes ein resourcesVerzeichnis unter dem resourcesVerzeichnis, erstellen Sie ein META-INFVerzeichnis unter dem META-INFVerzeichnis, erstellen Sie ein gradle-pluginsVerzeichnis unter dem gradle-pluginsVerzeichnis und erstellen Sie eine propertiesDatei unter dem Verzeichnis
propertiesDie Datei kann von Ihnen selbst benannt werden, muss jedoch .propertiesenden, zcom.renxh.plugin.properties
Schließlich müssen wir propertiesdie Klasse angeben, in der wir das Plug- In in der Datei implementierenimplementation-class=com.renxh.Text

Bisher wurde unser Plug-In-Projekt geschrieben. Führen Sie das Plug-In ein, das wir im Modul geschrieben haben apply plugin:'com.renxh.plugin', und führen Sie dann die Aufgabe des Plug-Ins aus../gradlew haha

Ausgabe

> Task :mylibrary:haha
执行自定义插件 haha task
执行阶段，task ':mylibrary:haha'耗时：0ms

Diese Form des Schreibens kann in den Modulen unseres gesamten Projekts verwendet werden, ist jedoch nur auf dieses Projekt beschränkt und kann nicht in anderen Projekten verwendet werden.

Benutzerdefiniertes Modul, Maven hochladen

Die zweite Möglichkeit, Plug-Ins zu schreiben, kann nur in diesem Projekt verwendet werden, während andere Projekte nicht verwendet werden können. Manchmal benötigen wir ein Plug-In, um in mehreren Projekten verwendet zu werden, und dann müssen wir das Plug-In in maven hochladen

Erstellen Sie zuerst einen java module, der Name kann beliebig sein, nur behalten build.gradleund src/mainandere Dateien werden gelöscht
Ändern Sie den Inhalt in Gradle

apply plugin: 'groovy'  //必须
apply plugin: 'maven'  //要想发布到Maven，此插件必须使用


dependencies {
    
    
    implementation gradleApi() //必须
    implementation localGroovy() //必须
}
repositories {
    
    
    mavenCentral() //必须
}


def group='com.renxh.cusplugin' //组
def version='2.0.0' //版本
def artifactId='myplugin' //唯一标示


//将插件打包上传到本地maven仓库
uploadArchives {
    
    
    repositories {
    
    
        mavenDeployer {
    
    
            pom.groupId = group
            pom.artifactId = artifactId
            pom.version = version
            //指定本地maven的路径，在项目根目录下
            repository(url: uri('../repos'))
        }
    }
}

Im Vergleich zur buildSrcLösung wird dadurch die Maven-Unterstützung und eine uploadArchivessolche Aufgabe hinzugefügt. Die Aufgabe dieser Aufgabe besteht darin, das lokale Plug-In zu verpacken und in das lokale Maven-Warehouse hochzuladen. Hier sind ../reposdie Repos im Projektstammverzeichnis aufgeführt. Die beiden .Rollbacks zweimal Rollback in das Projektstammverzeichnis

Beim src/mainGenerieren einer groovyDatei und Generieren propertieseiner Datei sowie beim buildSrcProgrammieren der Konvergenz

Schreiben Sie ein Plug-In

class CustomPlugin implements Plugin<Project>{
    
    

    @Override
    void apply(Project project) {
    
    
        project.task("cusplugin"){
    
    
            doLast{
    
    
                println("cusplugin任务执行111")
            }
        }
    }
}

./gradlew CusPlugin:uploadArchivesFühren Sie dann die Aufgabe uploadArchives aus, und ordnen Sie das Repos-Verzeichnis wie in der Abbildung gezeigt im Projektstammverzeichnis an:

reposDirectory ist ein lokales MavenLager, com/renxh/cuspluginin dem Skript angegeben wird group, mypluginim Namen Skriptmodul angegeben ist, ist eine eindeutige Kennung, ist das Skript 1.0.0version

Nach dem Generieren des lokalen Maven-Repositorys müssen Sie auf die Plugins im lokalen Maven-Repository verweisen. Zunächst müssen Sie der build.gralde im Stammverzeichnis Folgendes hinzufügen:


buildscript {
    
    
    repositories {
    
    
        google()
        jcenter()
        //引入本地仓库
        maven {
    
    
            url uri('./repos') //指定本地maven的路径，在项目根目录下
        }
    }
    dependencies {
    
    
        classpath 'com.android.tools.build:gradle:3.5.3'
        //引入本地仓库中的插件依赖
        classpath 'com.renxh.cusplugin:myplugin:1.0.0'

        
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }


}

Das durch classpath angegebene Pfadformat lautet wie folgt:

Diese drei Parameter werden im build.gradleSkript konfiguriert, wenn das Warehouse generiert wird

classpath '[groupId]:[artifactId]:[version]'

Nach der Konfiguration kann es im Modul verwendet werden

apply plugin: 'com.android.application'
apply from: rootProject.getRootDir().getAbsolutePath() + "/utils.gradle"
apply plugin:'com.renxh.cusplugin'

Schließlich können Sie die Aufgaben im Plugin ausführen ./gradlew app:cusplugin

> Task :app:cusplugin
cusplugin任务执行111
执行阶段，task ':app:cusplugin'耗时：0ms

Erweiterung des Plugins

Wir können auch Parameter für das Plug-In konfigurieren, wenn das Plug-In ausgeführt wird. Das Plug-In Extensionwird verwendet, um die Parameter an das Plug-In zurückzugeben

Unten werde ich das obige Plug-In ergänzenExtension

Erstellen Sie zuerst eine Entitätsklasse, um Parameter zu empfangen

package com.renxh.cusplugin
class MyExtension {
    
    
    String name;
    int age;
}

Gehen Sie dann zur Plugin-Klasse, um die Erweiterung hinzuzufügen

class CustomPlugin implements Plugin<Project>{
    
    

    @Override
    void apply(Project project) {
    
    
		//添加扩展
        project.extensions.add('myextension',MyExtension)

        project.task("cusplugin"){
    
    
            doLast{
    
    
                println("cusplugin任务执行111")

                MyExtension extension = project.myextension
                //3.输出插件扩展属性
                println ">>>>>> name: ${extension.name} age:${extension.age}"
            }
        }
    }
}

Fügen Sie der Erweiterung über project.extensions.add die angepasste Entitätsklasse hinzu und geben Sie ihr einen Namen
Rufen Sie dann die erweiterte Entitätsklasse mit dem Namen ab
Holen Sie sich schließlich die Attribute in der Erweiterung

Laden Sie den Maven nach der Änderung erneut hoch

Nach dem Hochladen können Sie die erweiterte Entitätsklasse im Modul verwenden

apply plugin: 'com.android.application'
apply from: rootProject.getRootDir().getAbsolutePath() + "/utils.gradle"
apply plugin:'com.renxh.cusplugin'

myextension{
    
    
    name 'renxh'
    age 27
}

Führen Sie abschließend die Aufgabe im Plugin aus,./gradlew app:cusplugin

> Task :app:cusplugin
cusplugin任务执行111
>>>>>> name: renxh age:27
执行阶段，task ':app:cusplugin'耗时：2ms

Referenz

3 Möglichkeiten, Gradle-Plugins für Android anzupassen

Benutzerdefiniertes Plugin für Gradle

Gradle-Lernserie (3): Gradle-Plugin