Il s'agit d'un tutoriel très simple pour créer une application Java simple avec Gradle. Le but est de se faire une idée de Gradle. Il explique également comment installer et utiliser Gradle Wrapper.
Je n'expliquerai pas le script de construction dans Groovy, cette grammaire dans ce sens, ou quoi que ce soit du genre [^ 1]. Mais je pense que vous pouvez vous en faire une idée. [^ 1]: pas assez détaillé pour expliquer en premier lieu
C'est une condition que le JDK6 ou supérieur soit téléchargé. Vous n'avez pas besoin d'un IDE, juste d'un éditeur de texte.
Commencez par créer un projet Java à construire avec Gradle. Gardez le projet aussi simple que possible pour vous concentrer sur la description de Gradle.
Créez la structure de répertoires suivante sous votre répertoire préféré.
└── src
└── main
└── java
└── hello
Créez deux classes, "HelloWorld.java" et "Greeter.java", dans le répertoire src / main / java / hello.
src/main/java/hello/HelloWorld.java
package hello;
public class HelloWorld {
public static void main(String[] args) {
Greeter greeter = new Greeter();
System.out.println(greeter.sayHello());
}
}
src/main/java/hello/Greeter.java
package hello;
public class Greeter {
public String sayHello() {
return "Hello world!";
}
}
Installons Gradle.
Vous pouvez télécharger les binaires depuis http://www.gradle.org/downloads. Extrayez DL gradle-version-bin.zip et placez le chemin vers le dossier bin.
Vous pouvez également utiliser le programme d'installation suivant.
Exécutez la commande suivante pour voir si elle a été installée
gradle
Si l'installation réussit, vous verrez un message de bienvenue.
>gradle
Starting a Gradle Daemon (subsequent builds will be faster)
:help
Welcome to Gradle 3.2.1.
To run a build, run gradle <task> ...
To see a list of available tasks, run gradle tasks
To see a list of command-line options, run gradle --help
To see more detail about a task, run gradle help --task <task>
BUILD SUCCESSFUL
Total time: 8.667 secs
Ceci termine l'installation de Gradle.
gradle tasks Exécutez la commande suivante dans le répertoire du projet.
gradle tasks
La commande gradle tasks affiche les tâches qui peuvent être effectuées avec gradle. À ce stade, vous devriez voir les tâches de base suivantes:
:tasks
------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------
Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]
Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'hello'.
components - Displays the components produced by root project 'hello'. [incubating]
dependencies - Displays all dependencies declared in root project 'hello'.
dependencyInsight - Displays the insight into a specific dependency in root project 'hello'.
dependentComponents - Displays the dependent components of components in root project 'hello'. [incubating]
help - Displays a help message.
model - Displays the configuration model of root project 'hello'. [incubating]
projects - Displays the sub-projects of root project 'hello'.
properties - Displays the properties of root project 'hello'.
tasks - Displays the tasks runnable from root project 'hello'.
To see all tasks and more detail, run gradle tasks --all
To see more detail about a task, run gradle help --task <task>
BUILD SUCCESSFUL
Total time: 1.244 secs
Eh bien, cela n'a pas beaucoup de sens dans l'état initial, mais si vous voulez savoir quel type de tâches peut être effectué, c'est une bonne idée de garder à l'esprit que cette commande est utilisée.
Créez un fichier build.gradle directement sous le dossier du projet.
build.gradle
apply plugin: 'java'
Cette ligne indique que vous créez ce projet à l'aide d'un plug-in Java.
Exécutez à nouveau gradle tasks. Vous verrez de nouvelles tâches ajoutées, telles que la construction d'un projet, la création d'un JavaDoc et l'exécution de tests.
Construisons-le tout de suite.
gradle build
gradle build sera fréquemment utilisé à partir de maintenant. Comme son nom l'indique, il s'agit d'une commande pour exécuter une construction. Après quelques secondes, vous verrez "BUILD SUCCESS FUL" indiquant que la construction est terminée.
Jetez un œil au dossier build pour voir les résultats de la construction. Il existe plusieurs dossiers.
classes Contient le fichier .class lors de la compilation du code Java. Cette fois, HelloWorld.class'et'Greeter.class 'auraient dû être créés
dependency-cache Contient .jar pour les modules dépendants. Il est vide en ce moment.
libs La bibliothèque créée (généralement jar ou war) est stockée.
Maintenant que la construction est terminée, exécutons-la. Il est possible de l'exécuter en utilisant la commande java, mais comme c'est un gros problème, exécutons-le depuis gradle. Modifiez build.gradle comme suit.
build.gradle
apply plugin: 'java'
apply plugin: 'application'
mainClassName = 'hello.HelloWorld'
Le plug-in d'application vous permet de démarrer une application avec la commande gradle run.
>gradle run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
Hello world!
BUILD SUCCESSFUL
Total time: 1.786 secs
Jusqu'à présent, les échantillons ne dépendent d'aucune bibliothèque externe, il n'y a donc pas beaucoup de goût à utiliser gradle.
Par conséquent, modifions-le pour que non seulement "Hello World!" Mais aussi la date et l'heure actuelles soient affichées. Vous pouvez utiliser l'API de date et d'heure Java de la bibliothèque standard Java, mais pour des raisons d'explication, utilisons les bibliothèques Joda Time.
Tout d'abord, modifiez HelloWorld.java comme suit:
HelloWorld.java
package hello;
import org.joda.time.LocalTime;
public class HelloWorld {
public static void main(String[] args) {
LocalTime currentTime = new LocalTime();
System.out.println("The current local time is: " + currentTime);
Greeter greeter = new Greeter();
System.out.println(greeter.sayHello());
}
}
Hello World utilise l'heure locale de Joda Time pour obtenir et afficher l'heure actuelle.
Maintenant, lancez gradle build. Il échoue car Joda Time ne peut pas être résolu.
Maintenant, laissez gradle résoudre la dépendance. Veuillez changer build.gradle.
build.gradle
apply plugin: 'java'
apply plugin: 'application'
mainClassName = 'hello.HelloWorld'
repositories {
mavenCentral()
}
jar {
baseName = 'gs-gradle'
version = '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
compile "joda-time:joda-time:2.2"
testCompile "junit:junit:4.12"
}
Le bloc repositories spécifie que le référentiel central Maven sera utilisé pour le référentiel.
Le bloc jar spécifie le nom du jar. Dans ce cas, ce serait gs-gradle-0.1.0.jar.
Le bloc dependencies déclare les dépendances sur Joda Time. Plus précisément, la bibliothèque joda-time du groupe joda-time, version 2.2.
compile indique que la dépendance n'est valide qu'au moment de la compilation. C'est la portée compile dans Maven. Autres types de dépendances
providedCompile Requis au moment de la compilation, mais au moment de l'exécution comme l'API Servlet de dépendance fournie par le conteneur. Fourni à Maven.testCompile Dépendances requises lors de la compilation, du temps et des tests. Non inclus dans les artefacts de construction. Comme jUnit. Test à Maven.Maintenant, exécutez à nouveau gradle build. gradle résout la dépendance Joda Time du référentiel central Mave et la construction réussit.
Le projet devrait fonctionner correctement.
>gradle run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
The current local time is: 01:56:47.665
Hello world!
BUILD SUCCESSFUL
Total time: 1.308 secs
Gradle Wapper Lorsqu'il s'agit d'utiliser ce type d'outil dans un projet composé de plusieurs personnes, il est difficile de préparer des procédures d'installation pour d'autres membres et d'utiliser des versions différentes.
C'est là qu'intervient Gradle Wapper. En installant Gradle Wapper dans un projet, n'importe qui peut construire un projet avec la même version de gradle quel que soit l'environnement tel que Windows, Mac, Linux.
L'installation de Gradle Wapper est facile, il suffit d'exécuter la commande suivante directement sous le projet.
$ gradle wrapper --gradle-version 2.13
Lorsque la tâche est terminée, plusieurs dossiers et répertoires seront créés.
└── <project folder>
└── gradlew
└── gradlew.bat
└── gradle
└── wrapper
└── gradle-wrapper.jar
└── gradle-wrapper.properties
Ceci termine l'installation de Gradle Wrapper. C'est facile à utiliser, il suffit d'exécuter "gradlew (.bat)" directement sous le projet au lieu de la commande gradle.
./gradlew build
Bien sûr, vous pouvez également exécuter d'autres commandes.
./gradlew run
Confiez simplement le fichier créé par gradle init à git ou svn (et appuyez simplement sur cette commande et écrivez une ligne dans le readme) et personne n'aura à le faire via gradlew Vous pouvez utiliser gradle avec. C'est bien pensé.
Avec cela, je pense que l'atmosphère de Gradle a été grossièrement appréhendée. Il n'est pas possible de créer un projet à grande échelle avec le contenu de cet article uniquement. Cependant, l'obstacle à la lecture d'autres articles liés à Gradle aurait dû être abaissé. Obtenez les informations dont vous avez besoin et tirez le meilleur parti de Gradle.
J'espère que cet article vous a donné une chance de commencer à utiliser gradle.
Recommended Posts