Comment utiliser le système de modules dans Java 9 pour séparer et isoler le code

Comment utiliser le système de modules dans Java 9 pour séparer et isoler le code

À mesure que la taille des logiciels continue d'augmenter, la complexité du code continue d'augmenter. Pour mieux organiser et gérer le code, Java 9 a introduit le système de modules. L'émergence du système de modules résout le problème des dépendances traditionnelles des packages, rendant la séparation et l'isolation du code plus faciles et plus flexibles. Cet article explique comment utiliser le système de modules dans Java 9 pour réaliser la séparation et l'isolation du code.

1. Définition du module

En Java 9, nous pouvons utiliser le mot-clé module pour définir un module. Un module se compose d'un ensemble de packages et les droits d'accès des packages du module sont contrôlés via le mot-clé exports. Un module peut dépendre d'autres modules, et les dépendances entre modules sont exprimées via le mot clé require.

Voici un exemple de définition de module simple :

module com.example.myapp {
    requires java.base;
    requires com.example.mylib;
    exports com.example.myapp;
}

Dans cet exemple, com.example.myapp est un module qui dépend du module java.base et du module com.example.mylib. Il expose le package com.example.myapp au monde extérieur via le mot-clé exports, et d'autres modules peuvent accéder au package.

2. Utilisation de modules

Lors du développement d'applications Java, nous pouvons organiser le code en différents modules, chaque module est responsable de différentes fonctions. L’avantage est qu’il permet de mieux gérer le code, de réduire le couplage et d’améliorer la maintenabilité et la réutilisabilité du code.

Nous utilisons un exemple simple pour illustrer comment utiliser le système de modules pour séparer et isoler le code. Supposons que nous ayons un projet appelé myapp, composé de deux modules : myapp et mylib.

Tout d'abord, nous créons un module de mylib, qui contient une classe Helper :

module mylib {
    exports com.example.mylib;
}

Ensuite, nous créons un module de myapp, qui dépend du module mylib et utilise la classe Helper dans le module mylib :

module myapp {
    requires mylib;
    exports com.example.myapp;
}

Dans le module myapp , nous pouvons utiliser le mot-clé import pour introduire des classes dans le module mylib :

import com.example.mylib.Helper;

public class MyApp {
    public static void main(String[] args) {
        Helper helper = new Helper();
        helper.doSomething();
    }
}

En utilisant le système de modules, nous pouvons clairement séparer et isoler différents modules de code. Pendant la compilation et l'exécution, la machine virtuelle Java résout automatiquement les dépendances entre les modules et charge les modules requis.

3. Packaging et publication de modules

Dans Java 9, nous pouvons utiliser la commande jlink pour créer une image d'exécution autonome. L'image d'exécution contient tous les modules et dépendances requis par l'application et peut être exécutée directement dans l'environnement cible.

Supposons que nous ayons regroupé les modules myapp et mylib dans des fichiers jar. Nous pouvons utiliser la commande suivante pour créer une image d'exécution :

jlink --module-path modules --add-modules myapp --output image

Parmi eux, le paramètre --module-path spécifie le répertoire où se trouve le module, le paramètre --add-modules spécifie le module à empaqueter, et le Le paramètre --output spécifie le répertoire de sortie.

Après la création, nous pouvons exécuter directement l'image d'exécution autonome :

./image/bin/java -m com.example.myapp/com.example.myapp.MyApp

En utilisant la commande jlink, nous pouvons facilement empaqueter et publier une application autonome, réduisant ainsi le besoin de dépendances externes et améliorant l'efficacité de l'application. .

Résumé :

Le système de modules dans Java 9 nous offre de meilleures solutions d'organisation et de gestion du code. En définissant des modules et en utilisant des dépendances entre les modules, nous pouvons réaliser la séparation et l'isolation du code. L'émergence du système de modules rend la maintenance du code plus pratique, réduit le couplage et améliore la réutilisabilité et la maintenabilité du code. Dans le même temps, en utilisant la commande jlink, nous pouvons créer des images d'exécution autonomes pour empaqueter et publier des applications, réduisant ainsi le besoin de dépendances externes et améliorant la portabilité. Par conséquent, lors du développement d'applications Java, nous devons utiliser pleinement le système de modules de Java 9 pour optimiser la structure du code et le développement modulaire.

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!