Comment implémenter la modularisation et la technologie sous-jacente Jigsaw de Java

Pour les développeurs Java, la modularisation est une technologie très importante. Cela peut nous aider à mieux organiser le code, à réduire le couplage et à améliorer la maintenabilité et la lisibilité du code. Java 9 introduit le système de modules Jigsaw, qui offre une nouvelle approche modulaire permettant aux développeurs de créer, de gérer et d'utiliser plus facilement du code modulaire. Cet article présentera comment implémenter la modularisation et Jigsaw de la technologie sous-jacente de Java, et fournira des exemples de code spécifiques.

1. Qu'est-ce que la modularité ?

La modularisation fait référence à la division de l'ensemble de l'application en une série de modules (ou composants), chaque module a ses propres fonctions et responsabilités, et ils sont indépendants les uns des autres. En Java, un module peut contenir des classes, des interfaces et d'autres fichiers de ressources, et peut également spécifier des API fournies en externe et d'autres modules dépendants.

2. Introduction à Jigsaw

Jigsaw est une fonctionnalité majeure introduite dans Java 9. Elle offre une nouvelle approche modulaire qui permet aux développeurs de créer, de gérer et d'utiliser plus facilement du code modulaire. Jigsaw comprend principalement les fonctions suivantes :

1. Définir le module : les développeurs peuvent définir un module via le fichier module-info.java, qui contient le nom du module, l'API, les dépendances et d'autres informations.
2. Chemin du module : les modules peuvent référencer d'autres modules de manière plus intuitive, sans avoir besoin de les référencer via le chemin de classe.
3. Restreindre l'accès : les modules peuvent restreindre les droits d'accès d'autres modules via l'exportation et l'exposition pour améliorer la sécurité du code.
4. Outil jlink : vous pouvez utiliser l'outil jlink pour empaqueter une image d'exécution qui contient uniquement les modules d'application et leurs dépendances.

3. Implémentation de la modularisation et de Jigsaw

Ci-dessous, nous utilisons un exemple spécifique pour démontrer comment utiliser Jigsaw pour implémenter des applications Java modulaires. Nous allons créer une application simple qui contient deux modules : un module Hello pour imprimer Hello World et un module Greeting pour fournir des services d'impression Hello World.

1. Créer un module

Tout d'abord, nous devons créer un module appelé Hello, qui dépendra du module Greeting. Créez la structure suivante dans le répertoire racine du projet :

hello-module
|--src
   |--hello
      |--module-info.java
      |--com
         |--example
            |--hello
               |--Hello.java
|--greeting-module
   |--src
      |--greeting
         |--module-info.java
         |--com
            |--example
               |--greeting
                  |--GreetingService.java

2. Définissez les informations du module

Définissez les informations du module dans module-info.java du module Hello et du module Greeting respectivement :

module-info.java du module Hello :

module-info.java du module

module hello {
    requires greeting;
}

Greeting :

module greeting {
    exports com.example.greeting;
}

3. code d'implémentation

Ensuite, implémentons le code du module Hello et du module Greeting.

Hello.java du module Hello :

package com.example.hello;

import com.example.greeting.GreetingService;

public class Hello {
    public static void main(String[] args) {
        GreetingService greetingService = new GreetingService();
        System.out.println(greetingService.getGreeting());
    }
}

GreetingService.java du module Greeting :

package com.example.greeting;

public class GreetingService {
    public String getGreeting() {
        return "Hello, World!";
    }
}

4. Compilation et exécution

Après avoir terminé l'écriture du code, nous pouvons utiliser la commande javac pour compiler le module Hello et le Module de salutation respectivement :

javac -d out/hello --module-source-path hello-module/src hello-module/src/hello/module-info.java hello-module/src/com/example/hello/Hello.java

javac -d out/greeting --module-source-path greeting-module/src greeting-module/src/greeting/module-info.java greeting-module/src/com/example/greeting/GreetingService.java

Ensuite, nous pouvons utiliser la commande java pour exécuter le module Hello :

java --module-path out/hello --module hello/com.example.hello.Hello

Résumé

À travers les exemples ci-dessus, nous pouvons voir que le système modulaire Jigsaw nous offre une manière plus structurée et standardisée de organiser et gérer le code. Cela peut nous aider à réduire le couplage entre les modules et à améliorer la maintenabilité et la lisibilité du code. En étudiant attentivement Jigsaw, nous pouvons mieux l'exploiter pour créer des applications Java plus robustes, maintenables et évolutives. J'espère que cet article sera utile à tout le monde pour comprendre et utiliser la modularisation et le Jigsaw de la technologie sous-jacente de Java.

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!