JeKa : la façon la plus simple de démarrer avec Java pour de vrai

JeKa est un outil de construction Java moderne axé sur la simplicité.

Lorsqu'ils débutent avec Java, les développeurs se contentent généralement d'écrire du code, de le compiler et de l'exécuter. Cependant, cela ne suffit pas pour créer des applications ou des bibliothèques Java utiles que d’autres peuvent réutiliser. Pour construire quelque chose de pratique en Java, nous devons :

• Utilisez des bibliothèques tierces (par exemple, Guava, Gson, Commons CLI, etc.)
• Emballez et déployez l'application/la bibliothèque pour que d'autres puissent l'utiliser.

Cela se fait souvent avec des outils de build traditionnels comme Maven ou Gradle. Ces outils nécessitent un apprentissage important et peuvent impliquer une configuration fastidieuse.
Une alternative plus simple est JBang, qui vous permet d'écrire des applications Java presque à fichier unique et de les partager facilement.

D'autre part, Jeka offre une gestion et un déploiement simples des dépendances à la manière de JBang tout en vous permettant de créer des applications ou des bibliothèques multi-classes standard avec des tests appropriés inclus.

Élaborer une nouvelle base de code

Prérequis : Jeka doit être installé.

Astuce : Pour lister les options disponibles, exécutez : jeka base: --doc.

Pour créer une structure de base, prête à commencer le codage immédiatement, exécutez :

jeka base: scaffold scaffold.kind=APP

Vous obtiendrez la structure de projet suivante :

. 
├── jeka-src             <- Source root directory
│   ├── _dev             <- Optional package containing all non-prod (build and test)
│   │   ├── test
│   │   └── Build.java  
│   └── app              <- Sugested base package for production code/resources
│       └── App.java     
├── jeka-output          <- Generated dir where artifacts as jars, classes, reports or doc are generated
├── jeka.properties      <- Build configuration  (Java and jeka version, kben configurations, ...)
└── README.md            <- Describes available build commands

Tout votre code Java est censé être dans le dossier jeka-src.

_dev est un package spécial pour le code source et les dépendances utilisés uniquement pour le développement (par exemple, tests, builds). Si vous êtes nouveau sur Java, vous pouvez l'ignorer ou le supprimer.

L'exemple échafaudé inclut une classe App dans le package app. Vous pouvez ajouter ou modifier des classes dans n'importe quel package de votre choix.

Synchroniser avec IntelliJ

Pour synchroniser avec IntelliJ, exécutez :

jeka intellij: iml --force

Si les modifications n'apparaissent pas dans IntelliJ, accédez au répertoire racine du projet et exécutez : jeka intellij: initProject.

Ajouter des dépendances

La classe App.java déclare une annotation @JkDep pour référencer une bibliothèque. Vous pouvez ajouter autant de bibliothèques que nécessaire. Une bonne pratique consiste à déclarer toutes les bibliothèques dans la même classe de base.

@JkDep("com.github.lalyos:jfiglet:0.8.9")
@JkDep("com.fasterxml.jackson:jackson-bom::pom:2.18.2")
@JkDep("com.fasterxml.jackson.core:jackson-core")
@JkDep("com.fasterxml.jackson.core:jackson-annotations")
public class App {

    public static void main(String[] args) {
        ...
    }
}

Voir les détails sur les notations de dépendance.

De plus, vous pouvez copier-coller les fichiers JAR dans le répertoire suivant pour les inclure automatiquement en tant que dépendances :

├── jeka-boot      <- Jars included in the production classpath.

Déclarer les dépendances hors production

Déclarez la dépendance sur n'importe quelle classe sous le package _dev, pour ajouter une dépendance en les intégrant dans la production.

package _dev;

@JkDep("org.junit.jupiter:junit-jupiter:5.11.4")
@JkDep("org.mockito:mockito-junit-jupiter:5.15.2")
class Build extends KBean {
    ...
}

Rappel : N'oubliez pas de lancer jeka intellij: iml une fois que vous avez modifié les dépendances.

Exécutez votre application

L'application peut être exécutée en utilisant :

jeka base: scaffold scaffold.kind=APP

Pour nettoyer la compilation avant de démarrer, utilisez l'option --clean (-c pour faire court).

Si ce code source est hébergé dans un dépôt Git, l'application peut être directement exécutée en référençant le dépôt comme :

. 
├── jeka-src             <- Source root directory
│   ├── _dev             <- Optional package containing all non-prod (build and test)
│   │   ├── test
│   │   └── Build.java  
│   └── app              <- Sugested base package for production code/resources
│       └── App.java     
├── jeka-output          <- Generated dir where artifacts as jars, classes, reports or doc are generated
├── jeka.properties      <- Build configuration  (Java and jeka version, kben configurations, ...)
└── README.md            <- Describes available build commands

Créer une bibliothèque

Si vous souhaitez écrire une bibliothèque, au lieu d'une application, vous devez déclarer à la fois moduleId et le versioning afin de la publier sur un référentiel Maven :

jeka intellij: iml --force

Maintenant, vous pouvez publier votre bibliothèque en exécutant :

@JkDep("com.github.lalyos:jfiglet:0.8.9")
@JkDep("com.fasterxml.jackson:jackson-bom::pom:2.18.2")
@JkDep("com.fasterxml.jackson.core:jackson-core")
@JkDep("com.fasterxml.jackson.core:jackson-annotations")
public class App {

    public static void main(String[] args) {
        ...
    }
}

Testez votre code

Le code échafaudé contient déjà une classe de test _dev.test.MyTest, prête à être exécutée.

├── jeka-boot      <- Jars included in the production classpath.

Vous pouvez ajouter plus de tests dans n'importe quel package de votre choix. Cependant, gardez à l'esprit que les classes de test non situées dans le package _dev (ou ses sous-packages) seront incluses dans le JAR de production en tant que code mort.

Changer la version de Java

De nos jours, Java évolue rapidement, avec de nouvelles versions tous les six mois. JeKa fournit un moyen très pratique de basculer entre les versions de Java. Précisez simplement la version dans le fichier jeka.properties :

package _dev;

@JkDep("org.junit.jupiter:junit-jupiter:5.11.4")
@JkDep("org.mockito:mockito-junit-jupiter:5.15.2")
class Build extends KBean {
    ...
}

Cela installera automatiquement le JDK 23 lors de la prochaine compilation ou exécution de l'application.

Commandes de construction prédéfinies

Entre autres, Jeka propose les commandes suivantes :

jeka --program arg0 args1 ... # or `jeka -p` for short

Autres commandes :

jeka --remote [git repo url] --program arg0 arg1 ... # or jeka -r [git repo url] -p

Passer à la structure complète du projet

À mesure que la base de code grandit, vous vous sentirez peut-être plus à l'aise dans l'utilisation d'une structure de projet complète.
Passer au projet est facile, pour savoir comment procéder, visitez le didacticiel de création de projets.

Coder avec Kotlin

Vous pouvez également écrire du code Kotlin dans la base de code. Spécifiez simplement la version de Kotlin que vous souhaitez utiliser dans le fichier jeka.properties :

@base.moduleId=org.example:my-lib
@base.version=1.0.0-SNAPSHOT

Maintenant, vous pouvez modifier le code Kotlin comme indiqué ci-dessous, l'intégrer de manière transparente au code Java existant dans votre base de code, ou même créer une application 100 % Kotlin :

jeka maven: publish

Conclusion

Jeka propose un mode pratique pour commencer à écrire une application Java réelle sans le fardeau des outils de construction traditionnels.

Sa structure polymorphe permet de gérer progressivement une complexité et une taille croissantes, sans sacrifier la simplicité.

Ressources :

• Jéka
• Exemple d'application simple
• Exemple d'application Spring-Boot
• Tutoriel de création de base
• Autres exemples

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!