Création d'un projet (et d'un référentiel GitHub) à l'aide de Java et Gradle avec IntelliJ IDEA

Aperçu

Il s'agit de la procédure de la création d'un référentiel sur GitHub au développement sur IntelliJ IDEA dans un projet d'application Java à l'aide de Gradle.

Quoi utiliser

• GitHub
• IntelliJ IDEA
• Cet article utilise 2018.1.
• Gradle
• Cet article utilise la version 4.8
• JUnit --Cet article utilise JUnit5

table des matières

1. Créez un référentiel GitHub
2. Créez un projet avec IntelliJ IDEA
3. Paramètres du fichier de construction Gradle
4. Création de la source Java
5. Construire avec Gradle
6. Utilisez JUnit 5 pour les tests Gradle

Créer un référentiel GitHub

1. Ouvrez l'écran de création du référentiel
2. Entrez les informations du référentiel
   • Repository name

• Entrez votre nom préféré
  • Description(optional)
• L'explication définie ici est automatiquement décrite dans README.md
  • public/private
• Vérifiez qui en a besoin
  • initialize this repository with a README --Il est recommandé de vérifier, essentiellement de vérifier
  • Add .gitignore --Sélectionnez Java, mais il peut ou non être présent car il sera écrasé par le contenu .gitignore décrit ci-dessous.
• Si vous le créez, vous n'avez pas besoin de créer un nouveau fichier.
  • Add a license
• Sélectionnez si vous souhaitez obtenir une licence

3. Cliquez sur le bouton Créer un référentiel pour terminer

Créer un projet avec IntelliJ IDEA

Que faire ici

1. Créez un projet IntelliJ IDEA lors du clonage du référentiel GitHub
2. Vérifiez si le projet est lié à la fonctionnalité Gradle sur IntelliJ IDEA
3. Créez .gitignore

Que se passe-t-il si vous faites

• Les paramètres de construction deGradle seront reflétés dans le projet à tout moment, et IntelliJ IDEA importera automatiquement les bibliothèques de dépendances, etc.
• Les répertoires et fichiers créés par le système d'exploitation, l'EDI et les outils de construction qui ne sont pas gérés par le référentiel ne sont plus inclus dans les modifications du référentiel.

procédure

1. Ouvrez l'écran de démarrage d'Intellij IDEA
2. Cliquez sur Extraire à partir du contrôle de version
3. Sélectionnez Git et clonez le référentiel
4. Copiez l'URL de clonage du référentiel créé ci-dessus dans le presse-papiers et collez-la dans le champ URL :.
5. Le champ Répertoire: saisira automatiquement le nom du référentiel, modifiez-le si nécessaire.
6. Cliquez sur le bouton Cloner
7. Une boîte de dialogue indiquant Retirer à partir du contrôle de version apparaîtra. Cliquez sur le bouton Oui pour confirmer.
8. Créez un projet qui passe de l'écran de clonage à la création de projet
9. L'écran Importer un projet s'ouvre
10. Paramètres du projet
11. Créer un projet à partir de sources existantes et Importer un projet à partir d'un modèle externe peut être sélectionné, mais Importer un projet ... est sélectionné.
12. Eclipse, Gradle, Maven ... sont disponibles, mais sélectionnez Gradle
13. Cliquez sur le bouton Suivant
14. Paramètres de Gradle - Use auto-import

• Si vous le cochez, vous pouvez l'importer automatiquement, mais il peut devenir plus lourd à mesure que le projet se développe. --Il est recommandé de vérifier - Create directories for empty content root automatically --Si coché, les répertoires nécessaires tels que le dossier source seront créés lors de la création du projet. --Il est recommandé de vérifier - Group modules
• Configuration de la gestion des modules sur IntelliJ IDEA en tenant compte du système de modules apparu dans Java9
• en utilisant des groupes de modules explicites: spécifier explicitement des groupes --utilisation de noms qualifiés: spécifiez un groupe à partir de noms qualifiés ―― Peu importe, selon le contenu du projet - Create separate module per source set
• Si coché par défaut, vous pouvez créer un module pour chaque sous-projet. --Si vous avez un sous-projet Gradle, il est recommandé de le décocher ――J'essaye de le décocher
• Où se trouve Gradle - Use default gradle wrapper (not configured for the current project) - Use gradle "wrapper" task configuration - Use local gradle distribution ――Je le fais personnellement car il est facile de comprendre de spécifier directement Gradle home dans le troisième Use local ... - Gradle home
• Requis si Utiliser la distribution de gradle locale est sélectionné -Définissez le chemin absolu vers libexec sous le répertoire Gradle, tel que / ~ / gradle / 4.8 / libexec - Gradle JVM --Définissez la version JVM lors de l'exécution de Gradle
• Aucune confusion lors de la combinaison avec la JVM utilisée dans le projet - Project format --Sélectionnez .idea (basé sur un répertoire) sauf si vous êtes particulier à ce sujet

4. Cliquez sur le bouton Terminer pour terminer
5. Voulez-vous ajouter le fichier suivant à Git?

• Le répertoire .idea et les fichiers qu'il contient seront créés, alors demandez si vous souhaitez l'ajouter au référentiel Git. --Sélectionnez Non car le répertoire .idea est défini pour être ignoré par .gitignore.

7. L'écran du projet s'ouvre
8. Vérifiez si le projet est lié à la fonction Gradle
9. Confirmez la motivation du projet et la construction réussie sur l'écran de l'outil de construction en bas de la fenêtre

• Nom du projet: synchronisé avec succès s'affiche sur la première ligne --La construction de l'exécution est réussie
• Une icône verte est attachée à chaque ligne si elle réussit, et une icône rouge est attachée si elle échoue.

2. Le menu Gradle du projet s'affiche sur l'écran de l'outil Gradle sur le côté droit de la fenêtre. --Il est affiché sous forme de nom de projet (importation automatique activée), etc.
3. Créez .gitignore --Créez .gitignore directement sous le répertoire du projet avec le contenu décrit ci-dessous --Exclure les répertoires et fichiers inutiles de la validation

contenu .gitignore

Je fais référence au .gitignore de RxJava, et personnellement, il inclut le support pour chaque IDE et outil de construction, donc je pense qu'il est préférable de le définir dès le début.

#Créer le fichier de résultats seul
*.com
*.class
*.dll
*.exe
*.o
*.so

#Créer un fichier de package de résultats
*.7z
*.dmg
*.gz
*.iso
*.jar
*.rar
*.tar
*.zip

#fichier journal
*.log

#Généré par OS
.DS_Store*
ehthumbs.db
Icon?
Thumbs.db

#Fichier en cours de modification
*~
*.swp

#Généré par Gradle
.gradle
.gradletasknamecache
.m2
!gradle-wrapper.jar

#Généré par l'outil de construction
target/
build/

#Généré par IntelliJ IDEA
out
.idea
*.ipr
*.iws
*.iml
atlassian-ide-plugin.xml

#Généré par Eclipse
.classpath
.project
.settings
.metadata
bin/

#Généré par NetBeans
.nbattrs
/.nb-gradle/profiles/private/
.nb-gradle-properties

#Relation Scala
*.cache
/.nb-gradle/private/

#Généré par PMD
.pmd
.ruleset

Paramètres du fichier de construction Gradle

Que faire ici

1. Créez build.gradle
2. Description de la confirmation dans build.gradle

Que se passe-t-il si vous faites

--Si vous ajoutez le contenu à build.gradle, le changement sera détecté sur IntelliJ IDEA et la bibliothèque de dépendances et la construction seront exécutées automatiquement.

procédure

1. Créez un fichier build.gradle directement sous le répertoire du projet 2.Faites une description minimale dans build.gradle pour confirmation
2. Collez le texte de confirmation build.gradle ci-dessous
3. Build: Sync fonctionne avec les modifications apportées à build.gradle
4. Assurez-vous que les bibliothèques de dépendances sont ajoutées au chemin (Bibliothèques externes sur l'écran Outils de projet sur le côté gauche de la fenêtre)
5. OK si Junit5 est ajouté

Confirmer build.gradle

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.2.0'
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.2.0'
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: '5.2.0'
}

test {
    useJUnitPlatform()
}

Créer une source Java

Que faire ici

1. Créez un répertoire des sources et ressources Java pour le produit / les tests
2. Dans les paramètres du module, définissez le rôle (Marquer comme) du répertoire créé.
3. Assurez-vous que vous pouvez créer et exécuter la source Java pour votre produit
4. Assurez-vous que vous pouvez créer et exécuter la source Java de test

Que se passe-t-il si vous faites

• Vous pouvez créer, construire et exécuter des sources Java sur IntelliJ IDEA.
• Les tests peuvent être exécutés sur IntelliJ IDEA

procédure

1. Ouvrez l'écran de configuration du module
2. Cliquez avec le bouton droit de la souris sur l'écran de l'outil de projet
3. Cliquez sur Ouvrir les paramètres du module
4. Sélectionnez des modules
5. Sélectionnez un projet ouvert
6. Créez un répertoire et définissez Marquer comme dans l'onglet Sources
7. Créez chaque répertoire - src/main/java - src/main/resources - src/test/java - src/test/resources
8. Marquer comme paramètres --src / main / java: sélectionnez les sources --src / main / resources: Sélectionnez Ressources --src / test / java: Sélectionnez Tests --src / test / resources: sélectionnez Test Resources
9. Dans l'onglet Paths, définissez le répertoire de destination de sortie pour les builds sur IntelliJ IDEA
10. Sélectionnez Utiliser le chemin de sortie de compilation du module pour la sortie du compilateur.
11. Définissez le chemin de sortie: vers le répertoire du projet / out / production / classes
12. Définissez le répertoire du projet / out / test / classes dans Chemin de sortie Test:
13. Créez une source Java de produit pour vérification
14. Créez un programme approprié dans src / main / java 2.Assurez-vous que vous pouvez créer et exécuter IntelliJ IDEA lorsque vous écrivez la méthode principale
15. Pour exécuter, faites un clic droit sur la source et cliquez sur Exécuter "nom de classe. nom de méthode ()"
16. Le résultat est affiché sur l'écran Exécuter l'outil d'IntelliJ IDEA.
17. Création d'une source Java de test pour vérification
18. Créez un programme approprié dans src / test / java
19. Créez une classe de test avec le nom ~ Test
20. Créez une méthode de test avec la méthode avec @Test (l'importation réussit car JUnit5 est défini dans la bibliothèque de dépendances)
21. Essai de fonctionnement
22. Pour exécuter le test, faites un clic droit sur la source et cliquez sur Exécuter 'nom de la classe' (Si vous faites un clic droit sur la méthode, exécutez 'nom de la méthode ()')
23. Les résultats des tests sont affichés sur l'écran de l'outil d'exécution d'IntelliJ IDEA --La classe de test et la méthode de test sont dans le résultat

Source Java pour confirmation

produit

Main.java

public class Main {

	public static void main(String[] args) {
		System.out.println("test product");
	}

}

tester

MainTest.java

import org.junit.jupiter.api.Test;

public class MainTest {

	@Test
	public void test(){
		System.out.println("test test");
	}

}

Construire avec Gradle

Que faire ici

1. Ajoutez la classe principale à build.gradle
2. Construisez et testez avec la fonction d'exécution Gradle sur IntelliJ IDEA
3. Confirmez que le résultat du test est sorti en HTML

Que se passe-t-il si vous faites

• Vous pouvez voir que l'exécution de Gradle via IntelliJ IDEA peut exécuter diverses fonctions telles que la création, l'exécution et le test de la source sur le projet.
• Vous pouvez voir que vous pouvez exécuter des tests en utilisant JUnit 5 avec Gradle et afficher les résultats en HTML.
• En conséquence, il a été constaté qu'il n'y avait aucun problème pour relier IntelliJ IDEA et Gradle, et les paramètres du projet et de Gradle étaient terminés.

procédure

1. Ajouté à build.gradle

   //Spécifiez le plug-in d'application pour spécifier la classe exécutable et la classe contenant la méthode principale exécutable.
   apply plugin: 'application'
   //Spécifiez la classe cible d'exécution
   mainClassName = '<Classe source Java pour le produit>'
   //Si vous suivez l'exemple, mainClassName= 'Main'
   

2. Construisez avec Gradle via IntelliJ IDEA
3. Ouvrez l'écran de l'outil Gradle
4. Exécuter la construction de l'élément de construction
5. Construction réussie sur l'écran de l'outil Exécuter
6. Le fichier de résultat, tel que le fichier de classe, est généré directement sous le répertoire du projet.
7. Exécutez la classe principale de Gradle à IntelliJ IDEA
8. Ouvrez l'écran de l'outil Gradle
9. Exécutez l'élément d'application run
10. Sur l'écran de l'outil Exécuter, le résultat de l'exécution de la classe source Java du produit s'affiche.
11. Pouvoir tester de Gradle à JUnit 5 via IntelliJ IDEA
12. Ouvrez l'écran de l'outil Gradle
13. Exécuter le test de l'élément de vérification
14. Sur l'écran de l'outil Exécuter, le résultat du test de la source Java pour le test s'affiche.
15. Sur l'écran de l'outil Exécuter, cliquez sur l'icône avec une flèche sur la marque Gradle pour vérifier le résultat du test dans le navigateur.
16. Le résultat du test affiché sur le navigateur indique le nombre de digestions de test décrites dans la classe de test.

Qu'est-ce qui se passe à la fin

Structure du répertoire du projet

.gradle
.idea
build
out
	production
		classes
			Main.class
	test
		classes
			MainTest.class
src
	main
		java
	        Main
		resources
	test
		java
			MainTest
		resources
.gitignore
build.gradle
README.md

.gitignore

Comme ci-dessus.

build.gradle

//Spécifiez le plug-in java pour construire respectivement le main et le test
apply plugin: 'java'

//Spécifiez le référentiel à utiliser
repositories {
    //Utiliser le référentiel Maven
    mavenCentral()
}

dependencies {
    // JUnit
    // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.2.0'
    // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.2.0'
    // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-params
    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: '5.2.0'
}

//Paramètres d'exécution de test dans Gradle
test {
    //Paramètres pour exécuter Junit5 avec Gradle, Gradle4.Peut être décrit car Gradle prend en charge nativement Junit 5 à partir de 6
    useJUnitPlatform()
}

//Spécifiez le plug-in d'application pour spécifier la classe exécutable et la classe contenant la méthode principale exécutable.
apply plugin: 'application'
//Spécifiez la classe cible d'exécution
mainClassName = 'Main'

Autre

--Lorsque vous exécutez le wrapper de configuration de construction de Gradle, ce qui suit est créé

• Le répertoire gradle et les fichiers liés à l'encapsuleur gradle sont créés sous celui-ci. --gradlew est créé --gradlew.bat est créé