Quelle est la différence entre les instructions require et requires transitive en Java 9 ?

Question

Quelle est la différence entre nécessite y nécessite une transposition les déclarations de module dans la déclaration de module ?

Par exemple :

module foo {
    requires java.base;
    requires transitive java.compiler;
}

Answer 1

Récapitulatif de la lisibilité

Si le module bar requires module boire alors le système de modules...

• impose la présence de boire (appelé configuration fiable )
• permet à bar à lire boire (appelé lisibilité )
• permet au code en bar pour accéder aux classes publiques des paquets exportés dans boire (appelé accessibilité )

C'est exactement la même chose si bar requires transitive drink - boire doit être présent, peut être lu et accessible. En effet, pour bar y boire le site transitive Le mot-clé ne change rien.

Lisibilité implicite

Les modules en fonction de bar sont ceux qui sont touchés par transitive : Tout module qui lit bar peut également lire boire . En d'autres termes, la lisibilité de boire es implicite (c'est pourquoi on l'appelle lisibilité implicite ). Une conséquence est que client peut accéder boire Les types d'animaux.

Donc si bar requires transitive drink y customer requires bar alors client peut lire boire même si elle n'en dépend pas explicitement.

Cas d'utilisation

Mais pourquoi ? Imaginez que vous ayez un module dont l'API publique accepte ou renvoie le type d'un autre module. Disons que le module bar renvoie publiquement des instances de Drink une interface de l boire module :

// in module _bar_
public class Bar {

    // `Drink` comes from the module _drink_,
    // which _bar_ requires
    public Drink buyDrink() { /* ... */ }

}

Dans cet exemple, bar utilise une requires pour boire . Maintenant, dites, client dépend de bar afin que tout son code puisse appeler Bar::buyDrink . Mais que se passe-t-il quand c'est le cas ?

Le système de modules se plaint que client ne lit pas boire et ne peut donc pas accéder Drink . Pour réparer cela, client devrait également dépendre de boire . Quelle corvée ! Quelle est l'utilité d'un bar que l'on ne peut pas utiliser immédiatement ?

C'est pour cette raison que la lisibilité implicite a été introduite : pour qu'un module qui utilise les types d'un autre module dans sa propre API publique soit immédiatement utilisable. sans obligeant l'appelant à rechercher et à exiger tous les modules concernés.

Donc si bar requires transitive drink , client peut commencer à acheter des boissons sans avoir à require drink - require bar suffit. Comme il se doit.

Answer 2

La principale différence entre les deux est l'accès d'un module dépendant de l'un à l'autre.

Si un module exporte un paquet contenant un type dont la signature fait référence à un paquetage dans un second module, alors la déclaration du premier module doit inclure un requires transitive dépendance à l'égard de la seconde. Ce site s'assurera que les autres modules qui dépendent du module premier module seront automatiquement capables de lire le second module et, d'accéder à tous les types des paquets exportés de ce module.

---

Disons que pour votre cas d'utilisation :-.

module foo {
    requires java.base;
    requires transitive java.compiler;
}

~> Tout module qui dépend de la foo lira automatiquement l'adresse java.compiler module

~> D'autre part, pour accéder au module java.base ils doivent préciser un requires clause à nouveau.

module bar {
    requires foo; // java.compiler is available to read
    requires java.base; // still required
}

Answer 3

requires décrit le processus de résolution sur la façon dont les modules sont dépendants les uns des autres.

Ligne de citations

Une directive 'requires' (indépendamment de 'transitive') exprime qu'un module dépend d'un autre module. un module dépend d'un autre module. L'effet de la Le modificateur "transitif" permet de faire en sorte que des modules supplémentaires dépendent également de l'autre module . Si le module M 'nécessite un N transitif', alors non seulement dépend de N, mais tout module qui dépend de M dépend également de N. N. Cela permet de remanier M de manière à ce qu'une partie ou la totalité de son contenu peut être déplacé vers un nouveau module N sans casser les modules qui ont une directive qui ont une directive 'requires M'.

En bref :

requires - Le module M dépend d'un autre module N.

requires transitive - module supplémentaire dépend implicitement de l'autre module. Par exemple, si le module M dépend de N, et que l'autre module P dépend de M, alors il dépend implicitement de N également.

Answer 4

Nicolai a expliqué en détail. Je ne donne ici qu'un exemple spécifique tiré du code JDK. Considérons le module jdk.scripting.nashorn. Le module-info de ce module est le suivant :

http://hg.openjdk.java.net/jdk9/dev/nashorn/file/17cc754c8936/src/jdk.scripting.nashorn/share/classes/module-info.java

Il y a cette ligne :

requires transitive java.scripting;

Cela s'explique par le fait que jdk.scripting.nashorn dans l'API propre au module jdk.scripting.api.scripting accepte/renvoie les types de javax.script du paquet de l java.scripting module. Ainsi, jdk.scripting.nashorn indique au JMPS que tout module qui dépend de jdk.scripting.nashorn dépend aussi automatiquement du module java.scripting !

Maintenant, le même module jdk.scripting.nashorn utilise cette ligne :

    requires jdk.dynalink;

pour un autre module jdk.dynalink . C'est parce que aucun des paquets exportés (l'"API") du module jdk.scripting.nashorn utilise des types du module jdk.dynalink. L'utilisation de jdk.dynalink par jdk.scripting.nashorn est purement un détail d'implémentation.

Answer 5

La spécification du langage Java pour Java 9 l'explique en termes très simples. Dans la section sur Dépendances des modules :

El requires spécifie le nom d'un module sur lequel le module courant a une dépendance.

...

El requires Le mot clé peut être suivi du modificateur transitive . Ainsi, tout module qui requires le module courant a une dépendance implicitement déclarée sur le module spécifié par la balise requires transitive directive.

En d'autres termes :

• si le module X requires module Y,
• et le module Y requires transitive module Z,
• alors le module X est aussi (implicitement) requires module Z.