Cet article fera partie d'une série. (inachevé) Je pense à la configuration suivante.
・ Problème-(Publié) J'expliquerai le contexte et le thème de cet article, ainsi que le dessin terminé. ・ Construction de l'environnement Gradle-cet article Décrit la gestion des versions par gradle et l'intégration de l'environnement de construction java / js.
・ Construction de l'environnement IDE - (non publié) Explique la procédure de construction de l'environnement lorsque le développeur effectue la programmation, le test unitaire et le débogage manuel.
Voir Article précédent pour les besoins de ce dont nous parlons. Dans cet article, par exemple, le projet se plongera dans la procédure de l'équipe de normalisation (ou). Cependant, gradle est trop profond pour expliquer, donc pour le moment, je voudrais faire en sorte que tout le sentiment puisse être lu.
Les éléments sous l'espace de travail expliqués cette fois sont comme ça.
Projet de structure de fichier pour l'espace de travail(En supposant un environnement Windows)
/workspace : gradle, eclipse,Espace de travail commun VS Code
/gradle :gradle à la maison
/wrapper :Emplacement de stockage de l'emballage Gradle
/tasks :Lors de la création de votre propre tâche
/xxTask.gradle
/buildSrc :Lors de la création de votre propre plug-in
/src :
/main :
/groovy :
/xxPlugin.groovy
/build.gradle :Créez des définitions qui peuvent être appliquées à tous les projets
/gradle.properties:Si vous avez besoin de propriétés
/settings.gradle:Énumérer les dossiers de projet
/gradlew.bat :Gradle parent-wrapper
Le premier est la conception de l'interface de commande. Nous allons procéder au travail en visant l'état où l'affichage est affiché lorsque l'utilisateur effectue des tâches gradlew.
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).
Tâches de gestion de version
------------
pull -Mettre à jour l'espace de travail avec le contenu du référentiel distant
push -Refléter les modifications de l'espace de travail vers le référentiel distant
Créer des tâches
---------
clean -Effacez l'espace de travail et créez des fichiers pour chaque projet
assemble -Créer une bibliothèque ou une application pour chaque projet
test -Tester la bibliothèque ou l'application pour chaque projet
apidoc -Spécifications de l'API de sortie pour chaque projet
package -Placez la bibliothèque de chaque projet afin qu'elle puisse être référencée par d'autres projets.
Tâches de configuration de l'espace de travail
---------------
init -Initialiser l'espace de travail
clone -Dupliquer le référentiel local à partir du référentiel distant
Est-il important de rendre les commandes de gestion de version disponibles à partir de gradle et de garder les commandes de construction communes aux projets java / js? Bien sûr, c'est la même chose même si d'autres langues entrent en jeu. Par conséquent, les commandes saisies par les utilisateurs seront toujours les mêmes, que la gestion des versions soit SVN ou Git, que la langue soit java, js ou d'autres langues.
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'.
Créer des tâches
---------
clean -Effacer le fichier de construction dans le projet
assemble -Créez une bibliothèque ou une application dans votre projet
test -Tester une bibliothèque ou une application dans votre projet
apidoc -Sortir les spécifications API du projet
package -Organisez les bibliothèques dans le projet afin qu'elles puissent être référencées par d'autres projets.
Ceci est un exemple, mais les commandes du projet que les développeurs utiliseront fréquemment ont des restrictions fonctionnelles. Dans cet exemple, j'ai essayé d'utiliser uniquement la commande build.
Voyons maintenant comment créer un menu comme celui ci-dessus. En passant, comme mentionné ci-dessus, c'est une description de type TIPS pour se concentrer sur les points principaux. Veuillez noter qu'il n'y a pas de coin comme la totalité du code source.
Je pense que tu peux faire une grande image avec juste ça
workspace/settings.gradle
// project1:projet java
// project2;projet js
include 'project1', 'project2'
workspace/gradle.properties
project1.type=java
project2.type=js
workspace/build.gradle
// rootproject(workspace)Tous les projets, y compris
configure(allprojects) {
println "Paramètres communs à tous les projets> $project"
...
}
// rootproject
configure(rootproject) {
println "paramètres de l'espace de travail> $project"
...
}
// rootproject(workspace)Tous les projets non compris
configure(subprojects) {
println "Paramètres communs aux projets autres que root> $project"
...
}
//projet java
configure(subprojects.findAll{ projectType(it) == 'java'}) {
println "Paramètres communs pour les projets Java> $project"
...
}
//projet js
configure(subprojects.findAll{ projectType(it) == 'js'}) {
println "Paramètres communs pour les projets js> $project"
...
}
//Fonction pour obtenir le type de projet
// gradle.Obtenir le contenu défini dans les propriétés
String projectType(Project p) {
def t
try { t = getProperty("${p.name}.type") } catch (e) {}
return t ?: 'others'
}
Si vous exécutez la tâche avec les paramètres ci-dessus, vous obtiendrez la sortie suivante.
workspace
C:\develop\workspace>gradlew projects
> Configure project :
Paramètres communs à tous les projets> root project 'workspace'
Paramètres communs à tous les projets> project ':project1'
Paramètres communs à tous les projets> project ':project2'
paramètres du projet racine> root project 'workspace'
Paramètres communs pour les projets Java> project ':project1'
Paramètres communs aux projets javascript> project ':project2'
> Task :projects
------------------------------------------------------------
Root project
------------------------------------------------------------
Root project 'workspace'
+--- Project ':project1'
\--- Project ':project2'
Vous pouvez maintenant appliquer les paramètres de tâche dans n'importe quelle étendue que vous souhaitez.
Une interface trop polyvalente pour les utilisateurs inexpérimentés peut être un obstacle à la compréhension. Rafraîchissons-nous en désactivant.
workspace/build.gradle
configure(allprojects) {
println "Paramètres communs à tous les projets> $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
}
Essayez de frapper des tâches avec les paramètres ci-dessus.
workspace
C:\develop\workspace>gradlew tasks
> Configure project :
Paramètres communs à tous les projets> 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).
C'était rafraîchissant. Mais je ne peux rien faire avec ça.
Je ne veux pas vraiment utiliser la tâche d'initialisation existante dans ce modèle. Je ne souhaite pas corriger les éléments initiaux et je souhaite prendre en charge plusieurs langues. Je vais donc l'écraser.
workspace/build.gradle
configure(rootproject) {
println "paramètres du projet racine> $project"
//Écraser la tâche d'initialisation
apply from: 'gradle/InitTask.gradle'
}
configure(subprojects) {
println "Paramètres communs aux projets autres que root> $project"
//Suppression de la tâche de démarrage
task('init').enabled = false
}
workspace/gradle/InitTask.gradle
//Enregistrer la tâche d'origine
def __originInitTask__ = init
//--------------------------------------
//Définition de la tâche d'initialisation du projet
//(Remplacer l'init de tâche existante)
//--------------------------------------
task init(overwrite: true).doLast {
println ':init '
//Un certain processus de réglage
//Par exemple, supprimez tous les dossiers et fichiers sous l'espace de travail ici.
//Au fait, construisez pendant le traitement de la tâche.Cela semble fonctionner correctement même si gradle est supprimé.
...
//Processus principal d'initialisation
//Par exemple, compressez la configuration minimale de l'espace de travail et
//Il est recommandé de le télécharger et de l'étendre.
//Il est facile à utiliser et à mettre en œuvre.
//Télécharger le zip
ant.get(
src: 'http://xxx.xxx.xxx/templete.zip',
dest: "${rootDir}/build/tmp/downloads/templete.zip")
//Copier du zip vers l'espace de travail
copy {
from zipTree "${rootDir}/build/tmp/downloads/templete.zip"
into "${rootDir}"
}
}
//Hériter des attributs nécessaires
//init.description = __originInitTask__.description
//init.group = __originInitTask__.group
//init.dependsOn = __originInitTask__.dependsOn
//Écrasement d'attribut
init.description = 'Initialiser l'espace de travail'
init.group = 'Paramètres de l'espace de travail'
Vous disposez maintenant d'une tâche d'initialisation pour la maintenance à distance. Il semble être efficace en tant que tâche préparatoire pour se connecter au système de gestion des versions ou en tant que commande de restauration lorsque l'environnement est endommagé de manière inattendue. Bien sûr, écrasez les tâches autres que init si nécessaire. Au fait,
workspace
gradlew init --type java-library --test-framework spock
En ce qui concerne java, il peut être correct de créer un environnement spock à l'avance et de le mettre dans le système de gestion de version. Est-ce que js est fait à la main?
Je souhaite créer une tâche de clonage qui crée un ensemble de dossiers de projet en coopération avec le système de gestion de version. Avec l'installation de git et les prémisses du système d'exploitation Windows, cela ressemble à ceci.
workspace/gradle.properties
project1.type=java
project2.type=js
remoteRepos=https://github.com/XXXX/xxx.git
workspace/build.gradle
//projet racine
configure(rootProject) {
//tâche init
apply from: 'gradle/InitTask.gradle'
//tâche de clonage
apply from: 'gradle/CloneTask.gradle'
}
workspace/gradle/CloneTask.gradle
task clone(group:'Paramètres de l'espace de travail', description:'Dupliquer le référentiel local à partir du référentiel distant', type:Exec) {
commandLine 'cmd', '/c', 'git', 'clone', getProperty('remoteRepos')
}
Si vous ne voulez pas que les utilisateurs installent manuellement git, vous pouvez envisager le plug-in d'intégration git de gradle.
Vous souhaiterez peut-être les regrouper sous forme de plug-in plutôt que de les définir individuellement. Dans ce modèle, je souhaite rassembler les tâches de construction sous forme de plug-in.
workspace/build.gradle
//projet java
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) {
//Définition de tâche unique
project.task(group:'Construire', description:'プロジェクト内のConstruire用ファイルをクリアします', 'clean') {
doLast { ... }
}
project.task(group:'Construire', description:'プロジェクト内のConstruire用ファイルをクリアします','assemble') {
doLast { ... }
}
project.task(group:'Construire', description:'Tester une bibliothèque ou une application dans votre projet','test') {
doLast { ... }
}
project.task(group:'Construire', description:'Sortir les spécifications API du projet','apidoc') {
doLast { ... }
}
project.task(group:'Construire', description:'Organisez les bibliothèques dans le projet afin qu'elles puissent être référencées par d'autres projets.','package') {
doLast { ... }
}
//Définition de la tâche par défaut
project.defaultTasks = ['clean', 'assemble', 'test', 'apidoc', 'package']
//Définition des extensions
project.extensions.create("option", OptionalExtension)
}
}
class OptionalExtension {
String opt1
String opt2
}
//Comment utiliser l'extension:
//Si la définition suivante est faite du côté du script de construction, elle peut être reçue et traitée du côté du plug-in.
// option {
// opt1 'Réglage de l'option 1'
// opt2 'Réglage de l'option 2'
// }
Cet exemple est la version java, mais si vous implémentez la version js et d'autres versions linguistiques de la même manière, les utilisateurs pourront gérer les commandes de la même manière sans écrire de build.gradle pour chaque projet.
Une fois que vous avez un plug qui est assez complet, vous voudrez peut-être l'ouvrir au public. Dans ce cas, n'oubliez pas de définir la déclaration du package et le plugin-id.
Si vous reproduisez la procédure jusqu'à présent, vous devez avoir rempli une liste de tâches comme le "point cible" ci-dessus. Je pense que nous avons créé un environnement de développement relativement standard qui convient à un environnement hybride dans lequel plusieurs langues sont mélangées dans une seule application.
Qu'as-tu pensé. Même si j'avais l'intention de le presser, c'est devenu assez long. .. .. Je pense qu'il y a des choses qui sont difficiles à comprendre, et inversement, il y a des endroits où vous devriez écrire ici, alors veuillez commenter si vous remarquez.
La prochaine fois, j'aimerais approfondir la procédure de test de débogage de programme à l'aide de l'EDI.
Recommended Posts