Créer un multi-projet Java avec Gradle
Comment faire un multi-projet avec Gradle.
Créer un fichier jar dans un seul projet
Avant d'effectuer plusieurs projets, créez et exécutez d'abord un fichier JAR dans un seul projet.
création de projet gradle
initialisation gradle
$ gradle init
Select type of project to generate:
1: basic
2: application
3: library
4: Gradle plugin
Enter selection (default: basic) [1..4] 1
Select build script DSL:
1: Groovy
2: Kotlin
Enter selection (default: Groovy) [1..2] 1
Project name (default: JavaMultiProject):
> Task :init
Get more help with your project: https://guides.gradle.org/creating-new-gradle-builds
BUILD SUCCESSFUL in 6s
2 actionable tasks: 2 executed
Modifier le fichier build.gradle
Modifiez un peu le fichier build.gradle créé automatiquement. L'important est de créer une tâche jar.
build.gradle
apply plugin: 'java'
apply plugin: 'application'
sourceCompatibility = 11
targetCompatibility = 11
repositories {
jcenter()
}
dependencies {
}
mainClassName = 'App'
jar {
manifest {
attributes 'Main-Class': "App"
}
}
Création de source
Créez une source à exécuter.
src/main/java/App.java
public class App {
public static void main(String[] args) {
System.out.println("Hello");
}
}
Essayez de construire et d'exécuter.
construire et exécuter
$ gradle build
BUILD SUCCESSFUL in 2s
5 actionable tasks: 1 executed, 4 up-to-date
$ java -jar build/libs/JavaMultiProject.jar
Hello
Vous avez créé et exécuté avec succès le fichier jar dans un seul projet.
Créer un multi-projet
Créons maintenant un multi-projet.
C'est la structure des répertoires.
Constitution
.(JavaMultiProject)
├── bar (Projet d'application)
│ ├── src
│ ├── build.gradle
├── foo (Projet d'application)
│ ├── src
│ ├── build.gradle
├── share (Projet à utiliser comme bibliothèque commune)
│ ├── src
│ ├── build.gradle
├── build.gradle
├── setting.gradle
Créez un répertoire.
python
$ mkdir -p bar/src/main/java
$ mkdir -p foo/src/main/java
$ mkdir -p share/src/main/java
Fixe setting.gralde
Pour multi-projets, définissez dans setting.gradle.
Spécifiez un sous-projet dans include.
setting.gradle
rootProject.name = 'JavaMultiProject'
include 'foo', 'bar', 'share'
Cela rend chaque répertoire for`` bar`` share reconnu comme un sous-projet.
IntelliJ IDEA reconnaît également le projet de cette manière.
 |
|---|
Correction de build.gradle
Dans build.gradle qui existe à la racine du projet, spécifiez les paramètres qui s'appliquent à tous les sous-projets en spécifiant des sous-projets.
build.gradle(root)
allprojects {
}
subprojects {
apply plugin: 'java'
sourceCompatibility = 11
targetCompatibility = 11
repositories {
jcenter()
}
}
Vient ensuite le sous-projet build.gradle.
Commençons par le projet d'application bar.
bar/build.gradle
apply plugin: 'application'
dependencies {
implementation project(":share")
}
mainClassName = 'com.example.Bar'
jar {
manifest {
attributes 'Main-Class': "com.example.Bar"
}
from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
Pour expliquer la partie importante, Le ʻimplementation project (": share") ʻin dependencies définit qu'il dépend d'un autre sous-projet, share.
Je spécifie également from ~ dans la tâche jar, ce qui signifie que les bibliothèques dépendantes sont incluses dans le jar du projet Bar.
Par ailleurs, si la méthode from n'existe pas, le fichier jar ne contient pas les bibliothèques dépendantes, donc une erreur NoClassDefFoundError est générée. Juste au cas où je serais coincé avec ça.
python
$ java -jar bar/build/libs/bar.jar
Exception in thread "main" java.lang.NoClassDefFoundError: com/example/Hello
at com.example.Bar.main(Bar.java:5)
Caused by: java.lang.ClassNotFoundException: com.example.Hello
at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
... 1 more
Le projet foo est presque le même que le projet bar, mais je le décrirai au cas où. Seul mainClassName est changé en Foo.
foo/build.gradle
apply plugin: 'application'
dependencies {
implementation project(":share")
}
mainClassName = 'com.example.Foo'
jar {
manifest {
attributes 'Main-Class': "com.example.Foo"
}
from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
build.gradle de share ne mentionne rien cette fois.
share/build.gradle
code
Enfin, j'écrirai le code.
bar/src/main/java/com/exmaple/Bar.java
package com.example;
public class Bar {
public static void main(String[] args) {
var hello = new Hello("Bar");
System.out.println(hello.say());
}
}
foo/src/main/java/com/exmaple/Foo.java
package com.example;
public class Foo {
public static void main(String[] args) {
var hello = new Hello("Foo");
System.out.println(hello.say());
}
}
share/src/main/java/com/exmaple/Hello.java
package com.example;
public class Hello {
private final String name;
public Hello(String name) {
this.name = name;
}
public String say() {
return name + " Hello!";
}
}
construire et exécuter
J'essaierai de construire. Les tâches de sous-projet sont exécutées avec «: (nom du projet): (nom de la tâche)».
De plus, la construction du projet partagé dont dépend la barre sera exécutée en même temps.
python
$ gradle :bar:build
BUILD SUCCESSFUL in 804ms
7 actionable tasks: 7 up-to-date
$ ls -l bar/build/libs/
total 8
-rw-r--r-- 1 ysaito staff 1591 4 29 21:15 bar.jar
Si vous décompressez le fichier jar créé pour référence, vous pouvez voir que Hello.class à l'intérieur du partage est inclus dans le fichier bar.jar créé.
Décompressez le pot et vérifiez
$ jar xvf bar.jar
META-INF/A été créé
META-INF/MANIFEST.MF a été déployé
com/A été créé
com/example/A été créé
com/example/Bar.la classe a été étendue
com/example/Hello.la classe a été étendue
Maintenant que nous avons un pot, exécutons-le.
python
$ java -jar bar/build/libs/bar.jar
Bar Hello!
$ java -jar foo/build/libs/foo.jar
Foo Hello!
référence
Guide de l'utilisateur Gradle-> Construire un multi-projet
Recommended Posts