Erstellen Sie eine Java- und JavaScript-Teamentwicklungsumgebung (Gradle-Umgebungskonstruktion)

Serienführung

Dieser Artikel wird in einer Reihe sein. (unvollendet) Ich denke über die folgende Konfiguration nach.

・ Problemstellung-(Posted) Ich werde den Hintergrund und das Thema dieses Artikels sowie die fertige Zeichnung erläutern. 　　 ・ Gradle-Umgebungskonstruktion - dieser Artikel Beschreibt die Versionsverwaltung durch Gradle und Integration der Java / JS-Build-Umgebung.

・ IDE-Umgebungskonstruktion (nicht veröffentlicht) Erläutert das Verfahren zur Erstellung der Umgebung, wenn der Entwickler Programmierung, Komponententest und manuelles Debuggen durchführt.

Bauverfahren

Siehe Vorheriger Artikel für den Zweck dessen, worüber wir sprechen. In diesem Artikel befasst sich das Projekt beispielsweise mit dem Verfahren des Standardisierungsteams (oder). Gradle ist jedoch zu tief, um es zu erklären, daher möchte ich es vorerst so gestalten, dass das gesamte Gefühl gelesen werden kann.

Arbeitsbereich Layout

Die diesmal unter dem Arbeitsbereich erläuterten Elemente sind wie folgt.

Entwurf einer Dateistruktur für den Arbeitsbereich(Angenommen, Windows-Umgebung)

/workspace        : gradle, eclipse,Gemeinsamer Arbeitsbereich für VS-Code
  /gradle         :Gradle nach Hause
    /wrapper      :Aufbewahrungsort der Gradle-Hülle
    /tasks        :Beim Erstellen Ihrer eigenen Aufgabe
      /xxTask.gradle
  /buildSrc       :Wenn Sie Ihr eigenes Plug-In erstellen
    /src          :
      /main       :
        /groovy   :
          /xxPlugin.groovy
  /build.gradle   :Erstellen Sie Definitionen, die projektübergreifend angewendet werden können
  /gradle.properties:Wenn Sie Eigenschaften benötigen
  /settings.gradle:Projektordner auflisten
  /gradlew.bat    :Elterngradle-wrapper

Zielpunkt: Aufgaben anzeigen

Erstens ist das Design der Befehlsschnittstelle. Wir werden mit der Arbeit fortfahren, die auf den Zustand abzielt, in dem die Anzeige angezeigt wird, wenn der Benutzer Gradlew-Aufgaben ausführt.

Im Arbeitsbereich

workspace

C:\develop\workspace>gradlew tasks

> Task :tasks

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Help tasks
----------
dependencies - Displays all dependencies declared in root project 'workspace'.
help - Displays a help message.
projects - Displays the sub-projects of root project 'workspace'.
properties - Displays the properties of root project 'workspace'.
tasks - Displays the tasks runnable from root project 'workspace' (some of the displayed tasks may belong to subprojects).

Versionsverwaltungsaufgaben
------------
pull -Aktualisieren Sie den Arbeitsbereich mit dem Inhalt des Remote-Repositorys
push -Reflektieren Sie Änderungen im Arbeitsbereich im Remote-Repository

Aufgaben erstellen
---------
clean -Löschen Sie den Arbeitsbereich und erstellen Sie Dateien für jedes Projekt
assemble -Erstellen Sie für jedes Projekt eine Bibliothek oder Anwendung
test -Testen Sie die Bibliothek oder Anwendung für jedes Projekt
apidoc -Ausgabe-API-Spezifikationen für jedes Projekt
package -Platzieren Sie die Bibliothek jedes Projekts so, dass andere Projekte darauf verweisen können.

Aufgaben zur Einstellung des Arbeitsbereichs
---------------
init -Initialisieren Sie den Arbeitsbereich
clone -Duplizieren Sie das lokale Repository aus dem Remote-Repository

Ist es wichtig, Versionsverwaltungsbefehle von gradle verfügbar zu machen und Build-Befehle für Java / JS-Projekte beizubehalten? Natürlich ist es auch dann so, wenn andere Sprachen hinzukommen. Infolgedessen sind die Befehle, die Benutzer eingeben, immer gleich, unabhängig davon, ob die Versionsverwaltung SVN oder Git ist, die Sprache Java, JS oder andere Sprachen.

Für Java / JS-Projekt

workspace/projectX

C:\develop\workspace\projectX>gradlew tasks

> Task :projectX:tasks

------------------------------------------------------------
All tasks runnable from project :projectX
------------------------------------------------------------

Help tasks
----------
dependencies - Displays all dependencies declared in project ':projectX'.
help - Displays a help message.
projects - Displays the sub-projects of project ':projectX'.
properties - Displays the properties of project ':projectX'.
tasks - Displays the tasks runnable from project ':projectX'.

Aufgaben erstellen
---------
clean -Löschen Sie die Build-Datei im Projekt
assemble -Erstellen Sie eine Bibliothek oder Anwendung in Ihrem Projekt
test -Testen Sie eine Bibliothek oder Anwendung in Ihrem Projekt
apidoc -Geben Sie die API-Spezifikationen des Projekts aus
package -Ordnen Sie die Bibliotheken im Projekt so an, dass sie von anderen Projekten referenziert werden können.

Dies ist ein Beispiel, aber die Befehle im Projekt, die Entwickler häufig verwenden, weisen einige funktionale Einschränkungen auf. In diesem Beispiel habe ich versucht, nur den Befehl build zu verwenden.

Anpassung der Aufgabe (Beschreibungsverfahren)

Lassen Sie uns nun untersuchen, wie Sie ein Menü wie das oben beschriebene erstellen. Übrigens, wie oben erwähnt, ist es eine TIPPS-ähnliche Beschreibung, sich auf die Hauptpunkte zu konzentrieren. Bitte beachten Sie, dass es keine Ecke gibt, in der der gesamte Quellcode vorhanden ist.

Geben Sie den Konfigurationsbereich an

Ich denke, Sie können mit genau diesem ein großes Bild machen

workspace/settings.gradle

// project1:Java-Projekt
// project2;js Projekt
include 'project1', 'project2'

workspace/gradle.properties

project1.type=java
project2.type=js

workspace/build.gradle

// rootproject(workspace)Alle Projekte einschließlich
configure(allprojects) {
    println "Einstellungen, die allen Projekten gemeinsam sind> $project"
    ...
}

// rootproject
configure(rootproject) {
    println "Arbeitsbereichseinstellungen> $project"
    ...
}


// rootproject(workspace)Alle Projekte ohne
configure(subprojects) {
    println "Einstellungen, die für andere Projekte als root gelten> $project"
    ...
}

//Java-Projekt
configure(subprojects.findAll{ projectType(it) == 'java'}) {
    println "Allgemeine Einstellungen für Java-Projekte> $project"
    ...
}

//js Projekt
configure(subprojects.findAll{ projectType(it) == 'js'}) {
    println "Allgemeine Einstellungen für js-Projekte> $project"
    ...
}

//Funktion zum Abrufen des Projekttyps
// gradle.Holen Sie sich die in Eigenschaften definierten Inhalte
String projectType(Project p) {
    def t
    try { t = getProperty("${p.name}.type") } catch (e) {}
    return t ?: 'others'
}

Wenn Sie die Aufgabe mit den obigen Einstellungen ausführen, erhalten Sie die folgende Ausgabe.

workspace

C:\develop\workspace>gradlew projects

> Configure project :
Einstellungen, die allen Projekten gemeinsam sind> root project 'workspace'
Einstellungen, die allen Projekten gemeinsam sind> project ':project1'
Einstellungen, die allen Projekten gemeinsam sind> project ':project2'
Root-Projekteinstellungen> root project 'workspace'
Allgemeine Einstellungen für Java-Projekte> project ':project1'
Einstellungen, die für Javascript-Projekte gelten> project ':project2'

> Task :projects

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'workspace'
+--- Project ':project1'
\--- Project ':project2'

Jetzt können Sie die Aufgabeneinstellungen in einem beliebigen Bereich anwenden.

Deaktivieren Sie unnötige Aufgaben

Eine für unerfahrene Benutzer zu vielseitige Benutzeroberfläche kann das Verständnis behindern. Lassen Sie uns durch Deaktivieren aktualisieren.

workspace/build.gradle

configure(allprojects) {
    println "Einstellungen, die allen Projekten gemeinsam sind> $project"

    task('buildEnvironment').enabled     = false
    task('components').enabled           = false
    task('dependencyInsight').enabled    = false
    task('dependentComponents').enabled  = false
    task('model').enabled                = false
    task('properties').enabled           = false
    task('wrapper').enabled              = false
    task('init').enabled                 = false
}

Versuchen Sie, Aufgaben mit den oben genannten Einstellungen auszuführen.

workspace

C:\develop\workspace>gradlew tasks

> Configure project :
Einstellungen, die allen Projekten gemeinsam sind> root project 'workspace'

> Task :tasks

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Help tasks
----------
dependencies - Displays all dependencies declared in root project 'workspace'.
help - Displays a help message.
projects - Displays the sub-projects of root project 'workspace'.
tasks - Displays the tasks runnable from root project 'workspace' (some of the displayed tasks may belong to subprojects).

Es war erfrischend. Damit kann ich allerdings nichts anfangen.

Aufgabe überschreiben

Ich möchte die vorhandene Init-Aufgabe in diesem Modell nicht wirklich verwenden. Ich möchte die anfänglichen Assets nicht reparieren und mehrere Sprachen unterstützen. Also werde ich es überschreiben.

workspace/build.gradle

configure(rootproject) {
    println "Root-Projekteinstellungen> $project"

    //Init Task überschreiben
    apply from: 'gradle/InitTask.gradle'
}
configure(subprojects) {
    println "Einstellungen, die für andere Projekte als root gelten> $project"

    //Unterdrückung von Init-Aufgaben
    task('init').enabled = false
}

workspace/gradle/InitTask.gradle

//Speichern Sie die ursprüngliche Aufgabe
def __originInitTask__ = init

//--------------------------------------
//Definition der Projektinitialisierungsaufgabe
//(Vorhandene Task-Init überschreiben)
//--------------------------------------
task init(overwrite: true).doLast {
    println ':init '

    //Einige Einstellungsvorgänge
    //Löschen Sie hier beispielsweise alle Ordner und Dateien im Arbeitsbereich.
    //Übrigens, erstellen Sie während der Verarbeitung der Aufgabe.Es scheint gut zu funktionieren, auch wenn Gradle entfernt wird.
    ...   

    //Hauptprozess der Initialisierung
    //Zipen Sie beispielsweise die minimale Arbeitsbereichskonfiguration und
    //Es wird empfohlen, es herunterzuladen und zu erweitern.
    //Es ist einfach zu bedienen und zu implementieren.

    //Zip herunterladen
    ant.get(
        src: 'http://xxx.xxx.xxx/templete.zip',
        dest: "${rootDir}/build/tmp/downloads/templete.zip")

    //Kopieren Sie von der Zip-Datei in den Arbeitsbereich
    copy {
       from zipTree "${rootDir}/build/tmp/downloads/templete.zip"
       into "${rootDir}"
    }
}

//Notwendige Attribute erben
//init.description    = __originInitTask__.description
//init.group          = __originInitTask__.group
//init.dependsOn      = __originInitTask__.dependsOn

//Attribut überschreiben
init.description    = 'Initialisieren Sie den Arbeitsbereich'
init.group          = 'Arbeitsbereichseinstellungen'

Sie haben jetzt eine Init-Aufgabe für die Fernwartung. Es scheint als vorbereitende Aufgabe zum Herstellen einer Verbindung zum Versionsverwaltungssystem oder als Wiederherstellungsbefehl wirksam zu sein, wenn die Umgebung unerwartet beschädigt ist. Überschreiben Sie bei Bedarf natürlich andere Aufgaben als init. Apropos,

workspace

gradlew init --type java-library --test-framework spock

In Bezug auf Java kann es in Ordnung sein, im Voraus eine Spock-Umgebung zu erstellen und diese in das Versionsverwaltungssystem einzufügen. Ist js handgemacht?

Neue Aufgabe erstellen

Ich möchte eine Klonaufgabe erstellen, die in Zusammenarbeit mit dem Versionsverwaltungssystem eine Reihe von Projektordnern erstellt. Mit der Git-Installation und der Windows-Betriebssystemprämisse scheint dies so zu sein.

workspace/gradle.properties

project1.type=java
project2.type=js

remoteRepos=https://github.com/XXXX/xxx.git

workspace/build.gradle

//Root-Projekt
configure(rootProject) {
    //Init-Aufgabe
    apply from: 'gradle/InitTask.gradle'
    
    //Aufgabe klonen
    apply from: 'gradle/CloneTask.gradle'
}

workspace/gradle/CloneTask.gradle

task clone(group:'Arbeitsbereichseinstellungen', description:'Duplizieren Sie das lokale Repository aus dem Remote-Repository', type:Exec) {
    commandLine 'cmd', '/c', 'git', 'clone', getProperty('remoteRepos')
}

Wenn Sie nicht möchten, dass Benutzer git manuell installieren, können Sie das Git-Integrations-Plug-In von gradle in Betracht ziehen.

Neuen Stecker erstellen

Möglicherweise möchten Sie sie als Plug-In gruppieren, anstatt sie einzeln zu definieren. In diesem Modell möchte ich die Aufgaben zum Erstellen als Plug-In zusammenstellen.

workspace/build.gradle

//Java-Projekt
configure(subprojects.findAll{ projectType(it) == 'java'}) {
    apply plugin: JavaBuildPlugin
}

workspace/buildSrc/src/main/groovy/JavaBuildPlugin.groovy

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

class JavaBuildPlugin implements Plugin<Project> {

    void apply(Project project) {
        
        //Definition der eindeutigen Aufgabe
        project.task(group:'Bauen', description:'プロジェクト内のBauen用ファイルをクリアします', 'clean') {
            doLast { ... }
        }
        project.task(group:'Bauen', description:'プロジェクト内のBauen用ファイルをクリアします','assemble') {
            doLast { ... }
        }
        project.task(group:'Bauen', description:'Testen Sie eine Bibliothek oder Anwendung in Ihrem Projekt','test') {
            doLast { ... }
        }
        project.task(group:'Bauen', description:'Geben Sie die API-Spezifikationen des Projekts aus','apidoc') {
            doLast { ... }
        }
        project.task(group:'Bauen', description:'Ordnen Sie die Bibliotheken im Projekt so an, dass sie von anderen Projekten referenziert werden können.','package') {
            doLast { ... }
        }
        
        //Definition der Standardaufgabe
        project.defaultTasks = ['clean', 'assemble', 'test', 'apidoc', 'package']
        
        //Definition von Erweiterungen
        project.extensions.create("option", OptionalExtension)
    }
}

class OptionalExtension {
    String opt1
    String opt2
}

//Verwendung der Erweiterung:
//Wenn die folgende Definition auf der Seite des Build-Skripts vorgenommen wird, kann sie auf der Plug-In-Seite empfangen und verarbeitet werden.
// option {
//   opt1 'Optionseinstellung 1'
//   opt2 'Optionseinstellung 2'
// }

Dieses Beispiel ist die Java-Version. Wenn Sie jedoch die js-Version und andere Sprachversionen auf dieselbe Weise implementieren, können Benutzer Befehle auf dieselbe Weise verarbeiten, ohne für jedes Projekt build.gradle zu schreiben.

Sobald Sie einen Stecker haben, der ziemlich vollständig ist, möchten Sie ihn möglicherweise für die Öffentlichkeit öffnen. Vergessen Sie in diesem Fall nicht, die Paketdeklaration und die Plugin-ID festzulegen.

Damit ist der Vorgang abgeschlossen

Wenn Sie den Vorgang bisher reproduzieren, sollten Sie eine Aufgabenliste wie den oben genannten "Zielpunkt" ausgefüllt haben. Ich denke, wir haben eine relativ standardmäßige Entwicklungsumgebung erstellt, die für eine Hybridumgebung geeignet ist, in der mehrere Sprachen in einer Anwendung gemischt sind.

Was haben Sie gedacht. Selbst wenn ich es quetschen wollte, wurde es ziemlich lang. .. .. Ich denke, es gibt einige Dinge, die schwer zu verstehen sind, und umgekehrt gibt es Stellen, an denen Sie hier schreiben sollten. Bitte kommentieren Sie, wenn Sie es bemerken.

Das nächste Mal möchte ich mich mit dem Verfahren zum Testen von Programmdebugs mithilfe der IDE befassen.