[JAVA] Gradle pour toucher et se souvenir

Qu'est-ce qui rend Gradle heureux?

Je pensais que c'était la même chose quand j'ai recommandé Docker aux gens, mais pour être honnête, il est difficile de transmettre la bonté. Que ce soit gradle ou Docker, chaque personne a son propre attrait, et même si vous essayez de transmettre la commodité, cela ne vous vient pas vraiment à l'esprit. Ceux qui écoutent restent dans la position «Je vois, ça me semble pratique». En premier lieu, les gens qui disent: «Sérieusement! Utilisons-le maintenant!» N'ont pas besoin d'expliquer parce qu'ils essaient de le toucher par eux-mêmes et essaient de comprendre ce que c'est. Je veux juste pouvoir "l'utiliser pour le moment". Cependant, il existe de nombreux cas où la compétence pour le faire n'a pas été atteinte. Pour le moment ... que dois-je faire?

Par conséquent, «formation» est attaché à la balise de cet article. Afin de pouvoir utiliser vous-même les nombreux outils utiles dans le monde, c'est probablement le meilleur moyen de créer un historique de l'utilisation de certains d'entre eux.

Cet article vous aidera à traiter gradle comme votre force. Au moment où je savais de quoi j'étais content, j'avais déjà une arme.

Installer gradle

Dans cet article, le système d'exploitation de la machine de développement est supposé être Windows. L'IDE est Eclipse. Par conséquent, certaines procédures et descriptions lui sont spécifiques. Si vous ne l'avez pas encore installé, vous devez absolument essayer d'utiliser le Gestionnaire de package. Il existe Homebrew etc. sur Mac, mais comme Windows est supposé, la procédure avec scoop est décrite. Commençons par lancer Power Shell avec des privilèges d'administrateur.

Autoriser l'exécution du script

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser -Force

Installer scoop

iex (new-object net.webclient).downloadstring('https://get.scoop.sh')

Installer gradle

scoop install gradle

Il y a quelques étapes supplémentaires pour passer par le proxy (comment plonger dans le proxy avec PowerShell est mon manuscrit (presque) procédure CUI de l'installation à l'utilisation de Docker for Window C'est un moment opportun car vous pouvez l'installer en copiant et collant 3 lignes de la commande. Il n'y a aucune perte à inclure un gestionnaire de paquets appelé scoop. Si vous saisissez cette opportunité, vous serez peut-être heureux plus tard.

Créer un dossier de projet

Utilisons gradle immédiatement. Quoi qu'il en soit, créez un dossier pour le projet. Créez un dossier avec le nom du projet. Cette fois, c'était "Yebisu". Bien sûr, c'est la bière que je bois maintenant. Une fois créé, utilisez l'Explorateur pour entrer dans le dossier Yebisu et appuyez sur ** Maj + Clic droit ** pour faire apparaître le menu. Il devrait y avoir un menu appelé ** Ouvrir la fenêtre PowerShell ici **. Sélectionnez-le et lancez PowerShell.

Créer un projet gradle

gradle init

Lorsque vous faites cela, il y a des questionnaires. Cette fois, entrons dans ce qui suit car il s'agit de java-appication.

• Select type of project to generate -> 2 (application)
• Select implementation language -> 3 (Java)
• Select build script DSL -> 1 (Groovy)
• Select test framework -> 4 (JUnit Jupiter) --Nom du projet -> Entrez tel quel (par défaut) --Source package-> Facultatif (yebisu cette fois)

PS D:\git-private\Yebisu> gradle init
Starting a Gradle Daemon, 1 busy Daemon could not be reused, use --status for details

Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2

Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Swift
Enter selection (default: Java) [1..5] 3

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1

Select test framework:
  1: JUnit 4
  2: TestNG
  3: Spock
  4: JUnit Jupiter
Enter selection (default: JUnit 4) [1..4] 4

Project name (default: Yebisu):

Source package (default: Yebisu): yebisu


> Task :init
Get more help with your project: https://docs.gradle.org/6.1/userguide/tutorial_java_projects.html

BUILD SUCCESSFUL in 1m 28s
2 actionable tasks: 2 executed

Vous venez de créer un projet. Veuillez laisser cette fenêtre PowerShell non fermée.

Faites-en un projet Eclipse

L'IDE cette fois est Eclipse. Utilisez le plug-in Eclipse pour en faire un projet Eclipse. Cette zone est une procédure de routine. Il devrait déjà y avoir build.gradle dans le dossier, alors ouvrons-le avec un éditeur de texte. Ajoutez une éclipse aux plugins. Ajoutez ** id'eclipse '** à la ligne suivante de ** id'application' **. Au fait, je n'aime pas les commentaires clairs, j'ai donc supprimé les commentaires.

build.gradle

plugins {
    id 'java'
    id 'application'
    id 'eclipse'
}

//Spécifiez l'encodage si nécessaire
compileJava.options.encoding = 'UTF-8'
compileTestJava.options.encoding = 'UTF-8'

repositories {
    jcenter()
}

dependencies {
    implementation 'com.google.guava:guava:28.1-jre'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
}

application {
    mainClassName = 'yebisu.App'
}

test {
    useJUnitPlatform()
}

Après la modification, exécutez la commande suivante dans PowerShell.

./gradlew eclipse

Cela créera un fichier **. Project ** **. Classpath **, etc., qui peut être importé dans Eclipse.

Importer dans Eclipse

Utilisez ** [Fichier] ** -> ** Importer ** dans la barre de menus pour afficher l'assistant d'importation.

Sélectionnez ** Projets existants dans l'espace de travail ** et cliquez sur ** Suivant **.

Entrez le chemin du projet que vous venez de créer dans ** Sélectionnez le répertoire racine **. Assurez-vous qu'il est coché dans ** Projets ** et appuyez sur le bouton ** Terminer **.

Il existe un fichier source appelé App.java, et main devrait y être créé.

--src / main / java Fichier source du corps principal --src / main / resources Fichier de ressources principal --src / test / java Fichier source du test de l'unité --src / test / resources Fichier de ressources de test unitaire

Ajouter une bibliothèque

Je souhaite utiliser FilenameUtils de ** Apache Commons IO **! Que feriez-vous dans un tel cas? Peut-être ai-je téléchargé le fichier Commons IO et l'ai ajouté aux dépendances du projet. Ce n'est pas nécessaire avec gradle. Tout ce que vous avez à faire est de trouver une ligne pour l'utiliser. Cherchons le mot de recherche sur Google comme ** FilenameUtils maven **. Vous devriez pouvoir trouver un site appelé ** MVNrepository **.

Si vous sélectionnez l'onglet ** Gradle **, le sort apparaîtra dans la zone de texte en dessous. Copions ce sort. Collez-le dans les dépendances de build.gradle. En fait, il est préférable de faire une implémentation de compilation, mais cette fois-ci, collons-la telle quelle.

build.gradle

dependencies {
    implementation 'com.google.guava:guava:28.1-jre'

	// https://mvnrepository.com/artifact/org.apache.commons/commons-io
	compile group: 'org.apache.commons', name: 'commons-io', version: '1.3.2'

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
}

Après avoir enregistré build.gradle, revenez à PowerShell et utilisez la commande suivante.

./gradlew eclipse

Le nom de fichier Utils est maintenant prêt à être utilisé

Revenons à Eclipse et mettons à jour le projet avec F5. Vous pouvez également cliquer avec le bouton droit sur le projet et actualiser. Si vous ouvrez l'arborescence ** Bibliothèques référencées **, vous trouverez commmons-io-1.3.2.jar. Essayons-le.

Si vous écrivez la ligne suivante dans main de App.java ...

System.out.println(FilenameUtils.getExtension("c:/foo/bar/hoge.fuga"));

Je pense que ** import org.apache.commons.io.FilenameUtils; ** sera automatiquement inséré avec ** Ctrl + Shift + 'O' **. Lançons-le tout de suite.

Dans l'image, il a été exécuté à partir d'Eclipse, mais il peut également être exécuté à partir de gradle.

./gradlew run

> Task :run
fuga
Hello world.

BUILD SUCCESSFUL in 2s
2 actionable tasks: 1 executed, 1 up-to-date

Réécrire correctement

compiler est en fait une ancienne façon d'écrire. La description du groupe, du nom et de la version peut être simplifiée.

build.gralde

compile group: 'org.apache.commons', name: 'commons-io', version: '1.3.2'
　↓
implementation 'org.apache.commons:commons-io:1.3.2'

En outre, plusieurs implémentations peuvent être écrites ensemble.

    implementation('com.google.guava:guava:28.1-jre'
                  ,'org.apache.commons:commons-io:1.3.2')

Ajouter Lombok

La plupart des bibliothèques peuvent être importées à l'aide de la méthode ci-dessus, mais le processeur d'annotations a une méthode différente. J'ajoute inconditionnellement ce qui suit aux dépendances car je me débattre dans la cage de ma propre personnalité que j'avais construite sans connaître Lombok.

build.gradle

	compileOnly 'org.projectlombok:lombok:1.18.4'
	annotationProcessor "org.projectlombok:lombok:1.18.4"
	testCompileOnly 'org.projectlombok:lombok:1.18.4'
	testAnnotationProcessor "org.projectlombok:lombok:1.18.4"

Si vous n'avez pas installé Lombok, vous devrez le faire. L'explication est laissée au site qui explique comment utiliser Lombok, mais en termes simples, vous pouvez démarrer Lombok.jar en double-cliquant et l'installer. Comme il est décrit dans eclipse.ini, si vous l'installez une fois, vous pouvez l'utiliser dans un projet en laissant les 4 lignes ci-dessus vides et en les collant avec Beton.

Faire un pot

Même jusqu'à présent, je pense que vous pouvez ressentir le merveilleux sentiment que les bibliothèques dans le monde peuvent être facilement importées et utilisées, et que toutes les dépendances sont importées. Je veux qu'il soit transmis. J'espère qu'il est transmis.

Quand j'ai commencé à utiliser springBoot, j'ai commencé à adorer davantage Gradle, mais cet article est le dernier à faire Jar.

En fait, Jar peut encore être fabriqué à ce stade.

./gradlew jar

C'est tout. Je pense qu'il y a un pot sous le dossier **. / Build / libs **. Ceci est juste un pot, donc cela ne fonctionne pas avec -jar, et le manifeste ne dit rien.

Et cette fois, mettons toutes les dépendances dans un fichier jar et en faisons un fichier jar exécutable qui peut fonctionner par lui-même. (Je ne le fais pas d'habitude) Ajoutez la description suivante à build.gradle.

build.gradle

jar {
    manifest {
        attributes('Implementation-Title': 'Yebisu'
                 , 'Implementation-Version': 1.0 
                 , 'Main-Class': 'yebisu.App')
    }
    from configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}

Si vous générez un jar avec ./gradlew jar``` et exécutez la commande suivante, cela fonctionnera correctement.

java -jar .\build\libs\Yebisu.jar

La version et le titre sont correctement inclus dans MANIFEST.MF.

MANIFEST.MF

Manifest-Version: 1.0
Implementation-Title: Yebisu
Implementation-Version: 1.0
Main-Class: yebisu.App

finalement

Cette prochaine étape consistera-t-elle à rédiger un test unitaire ou à couvrir Jacoco? build.gradle est écrit dans le langage Groovy. (Peut aussi être écrit en Kotlin)

Cela ne veut pas dire que lire et écrire Groovy ou Kotlin est obligatoire. Bien sûr, il vaut mieux l'avoir. Mais bon, si vous pouvez faire ce que vous voulez avec gradle, utilisez google pour demander au monde et la réponse générale est là. C'est tout. ** Parce que gralde n'est pas une nouvelle technologie. ** **

Il y a encore beaucoup de choses utiles dans le monde. Je pense que beaucoup d'entre eux ne sont pas appréciés par les coûts d'apprentissage. Cependant, la plupart des bibliothèques et des outils largement utilisés dans le monde valent le coût d'apprentissage.

C'est une mauvaise habitude de penser qu'il n'y a pas de problème car cela peut être fait avec la méthode actuelle. Par tous les moyens, je veux que vous recherchiez activement des armes, que vous les ramassiez et que vous les fabriquiez vous-mêmes. La différence de productivité ainsi cultivée sera énorme dans cinq à dix ans. 　 　 　 　 Peut.