Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Java 9 est disponible, la plateforme se met aux modules :
Tour d'horizon des nouveautés

Le , par Mickael Baron

454PARTAGES

9  0 
Après l'arrivée de Java 8 et ses nombreuses fonctionnalités en 2014, Java 9 pointe enfin le bout de son nez ce 21 septembre 2017. Java 9 inclut plus de 80 nouveautés toutes décrites dans un ensemble de JEP (Java Enhancement Proposal) disponibles à cette adresse : http://openjdk.java.net/projects/jdk9/.



À travers cette annonce, l'équipe Java de Developpez.com va vous donner un aperçu de ce qu’apporte le JDK 9 ; voici quelques-unes de ces nouveautés qui pourraient avoir un impact sur votre façon de programmer avec Java. Nous finirons par nos avis personnels respectifs. Ensuite cela sera votre tour ;-)

La modularisation via le projet Jigsaw

La modularisation annoncée depuis de nombreuses années, plusieurs fois repoussée, est LA grande nouveauté de Java 9. Elle a été décrite principalement dans la JEP 201. D’autres JEP sont liées à celle-ci tant le projet de modularisation est important. L’objectif principal du système des modules est de fournir un JDK qui puisse être structuré et de pouvoir charger seulement les modules nécessaires. Les applications du domaine de l’Internet des Objets (IOT en anglais) sont très demandeuses, car les systèmes hôtes sont généralement limités en ressources matérielles (mémoire, CPU…). Les développeurs Java pourront donc spécifier les modules du JDK et des bibliothèques tierces qui sont requis par leur application.

Sur le plan théorique, le système de module apporte également de nombreux autres avantages :

  • une plateforme plus facilement évolutive et maintenable ;
  • des gains en termes de performance et d'exécution puisque seuls les modules nécessaires sont chargés ;
  • des gains en termes de sécurité, car le principe modulaire permet de fournir le juste assez nécessaire au système. De plus, l’utilisation d’API privées est impossible si celles-ci ne sont pas explicitement exportées.


Comment ça fonctionne ?
Pour considérer une application tirant parti du système de modules, un fichier module-info.java est requis à la racine de votre projet. Un exemple de contenu de fichier module-info.java est proposé ci-dessous :

Code : Sélectionner tout
1
2
3
4
module com.developpez {
    requires java.sql;
    export fr.developpez.com.services;
}
Nous remarquons l’usage de nouveaux mots clés comme module, requires et export. Le premier étant utilisé pour nommer le module, le deuxième pour exprimer les modules nécessaires et le troisième pour indiquer les packages du module qui seront visibles à l’extérieur. Pour le dernier point, les packages souvent nommés impl pourront désormais être vraiment considérés comme privés.

Les personnes ayant une connaissance de OSGi ne seront pas surprises par la syntaxe hormis l’absence de numéro de version. En effet dans cette première version, Jigsaw a fait l’impasse sur les versions. Cet aspect est délégué aux outils de build comme Maven ou Gradle.

Bien sûr, comme toute grosse nouveauté, il y a quelques problèmes. On peut citer par exemple l’utilisation de la méthode setAccessible(boolean) qui permet d’accéder à des champs privés par réflexion. Cette méthode ne fonctionnera plus pour accéder à un champ privé contenu dans un module pour des raisons de sécurité et vous obtiendrez donc une belle exception de type : IllegalAccessError. Pour résoudre cela, il faudra « ouvrir » le module en utilisant le mot clé open sur le package ou plus globalement sur le module (voir ci-dessous).

Code : Sélectionner tout
1
2
3
4
module fr.developpez.com {
    requires java.sql;
    opens fr.developpez.com.services;
}
ou

Code : Sélectionner tout
1
2
3
4
open module fr.developpez.com {
    requires java.sql;
    exports fr.developpez.com.services;
}

Les outils ?
Au niveau des outils, il y a eu également des changements. Les commandes java et javac disposent naturellement de paramètres spécifiques pour prendre en compte le système de module. L’outil jlink (JEP 282) permet d'assembler plusieurs modules Java entre eux en tenant compte de leurs dépendances. Le résultat consiste en une image spécifique du runtime Java (JDK ou JRE) en intégrant son application. Enfin, sans être exhaustif, l’outil jdeps permet de connaître les modules dont dépend votre projet.

Fabriques pour les collections
La nouvelle version de Java 9 apporte de gros changements au niveau des API dédiées aux collections. Des méthodes statiques ont été ajoutées sur les interfaces de List, Set et Map pour initialiser des collections. Par ailleurs, les objets créés sont immutables (les attributs les contenant ne sont pas modifiables). L'objectif visé par cette amélioration décrite dans la JEP 269 étant bien sûr la création de petites collections et d'éviter une lourdeur syntaxique.

Avant Java 9, nous étions obligés de faire cela :
Code : Sélectionner tout
1
2
3
4
5
List<String> myList = new ArrayList<String>();
myList.add("Developpez.com");
myList.add("Aime");
myList.add("Java");
myList = Collections.unmodifiableList(myList);
Il y avait bien sûr l’exception de la classe Arrays pour créer des listes toutes prêtes. Malheureusement, il faut bien avouer qu’il n’est pas intuitif de faire appel à la classe Arrays pour créer des listes. Par ailleurs pour Set et Map, il n’y avait pas d’équivalent à la classe Arrays.

Avec Java 9, la création devient plus simple.

Code : Sélectionner tout
List<String> newList = List.of("Developpez.com", "Aime", "Java")
API pour la gestion des processus
Cette amélioration, décrite dans la JEP 102 permet à Java de mieux coexister avec le système. Initialement le développeur Java utilisait l’API Runtime.getRuntime().exec() puis avec Java 5 est apparue l’API ProcessBuilder. Malheureusement, il n’était pas possible de connaître le PID du processus courant, connaître les sous-processus, détruire des processus ou obtenir d’autres informations comme les paramètres d’exécution. Avec Java 9, les choses ont évolué dans le bon sens avec des nouvelles classes comme ProcessHandle et des ajouts dans la classe Process.

Pour récupérer le processus courant :

Code : Sélectionner tout
System.out.println(ProcessHandle.current())
Pour afficher le PID et les informations de la ligne de commande de tous les processus :

Code : Sélectionner tout
1
2
3
4
ProcessHandle.allProcesses().forEach(p -> System.out.println(p.getPid() + " " + p.info().commandLine()));
1 Optional[/usr/lib/jvm/java-9-openjdk-amd64/bin/jshell -v]
45 Optional[/usr/lib/jvm/java-9-openjdk-amd64/bin/java -agentlib:... jdk.jshell.execution.RemoteExecutionControl 34065]
137 Optional[/usr/bin/sleep 1h]
Multi-release des fichiers JAR
Le format du fichier JAR évolue. Celui-ci permet de gérer plusieurs implémentations d'une même classe au sein d'une archive unique. Avant Java 9, il était donc impossible de gérer plusieurs versions d’une même bibliothèque au sein d’une même archive.

Il était important d'apporter une solution pour assurer la compatibilité descendante, car Java 9 intègre de nouvelles API permettant de coder différemment . À l'exécution, la bonne version de la classe sera chargée automatiquement en fonction de la version de Java utilisé. Cette solution est décrite dans la JEP 238, elle est appelée Multi-Release JAR (MR JAR pour les intimes).

Si on considère deux classes Foo et Bar. La seconde contient deux implémentations une pour Java 9 et une autre pour toutes les versions antérieures à Java 9. La structure du JAR sera la suivante :

Code : Sélectionner tout
1
2
3
4
5
6
7
8
JAR root
- Foo.class
- Bar.class
+ META-INF
   - MANIFEST.MF
   + versions
     + 9
       - Bar.class

Comme on peut constater la racine (JAR root) n'évolue pas et Foo.class et Bar.class seront utilisées par toutes les versions de Java ne supportant pas MR JAR. Au contraire Foo.class et Bar.class localisée dans META-INF/versions/9/Bar.class seront utilisées pour la version 9 de Java.

Cette fonctionnalité a demandé des améliorations au niveau des outils de compilation et d'analyse. Les outils du JDK (javac, javap, jdeps...) ont été bien entendu impactés. Les outils de build comme Maven ou Gradle ont dû s'adapter pour la construction de cette nouvelle structure de JAR. Sur le papier tout fonctionne pour preuve dans ce dépôt GIT où des tests ont été réalisés.

Un shell Java : REPL jShell
De nombreux langages sont actuellement très populaires grâce à leur simplicité pour l’apprentissage ; à titre d’exemple le langage Python. Cette simplicité est en partie due à la présence d’une implémentation appelée REPL (Read Evaluate Print Loop). Grâce à ce mode de fonctionnement basé sur une boucle, l’interpréteur :

  1. Lit une expression (le R pour Read) ;
  2. Évalue une expression (le E pour Evaluate) ;
  3. Imprime sur la sortie standard (le P pour Print) ;
  4. Recommence (le L pour Loop).

Pour pallier ce manque, la version Java 9 offre un REPL appelé JShell (JEP 222) permettant une programmation interactive. JShell interprète directement des expressions sans avoir besoin qu’elles soient enveloppées dans une classe ou une méthode.

Outre l’aspect apprentissage, JShell pourra être utilisé pour tester du code rapidement en quelques lignes de code. Par exemple, vérifier si un service web est présent ou tester des agents de placement pour JavaFX. Il est également prévu de pouvoir intégrer JShell directement dans du code Java. On peut même envisager une alternative aux bons vieux scripts Bash et pourquoi pas des langages de script de la JVM comme Groovy.

Meilleure gestion du deprecated
L’annotation @Deprecated a été étoffée par deux attributs : l’un de type String since et l’autre de type boolean forRemoval (JEP 277). L’attribut since permet de préciser à partir de quand l’API a été annotée par @Deprecated et forRemoval précise que l’API en question risque d’être supprimée. Nous montrons ci-dessous un exemple de classe qui précise que cette API a été annotée @Deprecated depuis la version 2.5 et qu’elle n’est pas prévue pour être supprimée.

Code : Sélectionner tout
1
2
3
4
@Deprecated(since="2.5" forRemoval=false)
public class MaClassAMoi {
   …
}
Moteur de rendu Marlin
La JEP 265 a permis l’intégration d’un nouveau moteur de rendu Marlin permettant aux boîtes à outils Java (Java2D et JavaFX) d'être plus rapides. Précédemment les moteurs de rendu Pisces et Ductus étaient utilisés (Oracle JDK). Comme le moteur de rendu Marlin surpasse en termes de performance ces deux moteurs historiques (2006 et 1998), l'équipe de l'OpenJDK 2D a décidé de l'utiliser par défaut dans l'OpenJDK 9 et Oracle de son côté a fait de même pour Oracle JDK9 pour se débarrasser à terme de Ductus.

Sur le graphique ci-dessous, on remarque que les résultats obtenus par le moteur de rendu Marlin sont toujours plus efficaces que les autres rendus. On atteint parfois des ratios de l'ordre de 650 %.



MarlinFX a été finalement intégré en décembre 2016 (à la dernière minute), mais il reste désactivé par défaut dans JDK 9 (Java Pisces ou Native Pisces restent utilisés). L’équipe Java de Developpez.com a pu réaliser une interview de Laurent Bourgès, l’auteur principal de cette fonctionnalité : https://java.developpez.com/interview/laurent-bourges/

Améliorations en vrac
Les nouveautés de Java 9 sont nombreuses. Nous aurions aussi pu citer les points suivants :

  • Stream : de nouvelles méthodes ont été ajoutées dans les classes Stream et Collectors ;
  • Concurrence (JEP 266) : Java 9 est désormais un langage réactif dans le sens où une implémentation des Reactive Streams a été proposée. La nouvelle classe Flow propose trois interfaces intégrées pour le producteur (Publisher), consommateur (Subscriber) et une dernière pour la connexion entre le producteur et le consommateur ;
  • une nouvelle JavaDoc estampillée HTML 5 avec la possibilité de rechercher du contenu dans une zone de texte. C’est déjà une grosse évolution. Malheureusement, la recherche fulltext n’existe pas. Par ailleurs, les frames oldschool sont toujours présentes ;
  • un vrai client HTTP/2 (JEP 110) ;
  • G1, le garbage collector par défaut (JEP 248). Le garbage collector G1 est par défaut sur les architectures 32 et 64 bits. Il remplacera Parallel GC avec une approche plus intéressante pour les utilisateurs, car il diminuera les latences et son impact sur les ressources ;
  • Milling Project Coin (JEP 213). Ce projet a trait à de nombreuses évolutions de la syntaxe de Java. On notera la possibilité d’avoir des méthodes privées dans les interfaces afin de mutualiser du code utilisé dans les méthodes par défaut. On notera aussi la possibilité d’utiliser des variables finales dans le bloc Try-With-Resources ;
  • meilleure performance pour les chaînes de caractères proposées dans JEP 254, JEP 250 et JEP 280 ;
  • InputStream : trois nouvelles méthodes utilitaires ont été ajoutées dans la classe InputStream. readAllBytes() pour lire tout un flux, readNBytes() pour lire une portion d'un flux et transferTo() pour directement envoyer un flux d'entrée vers un flux de sortie.


Les avis
Nous avons demandé aux membres de l’équipe Java de donner leur avis concernant cette nouvelle version de Java. Que pensent-ils de cette version, quelles nouveautés ont-ils préférées et celles qu'ils trouvent décevantes ?

Avis 1 : Mickael Baron, responsable Java sur Developpez.com

On parle de Java 9 depuis longtemps. Cela se traduit par de nombreux articles et de présentations sur le sujet. Jigsaw LA fonctionnalité majeure de Java 9 est souvent présentée. Dans la plupart des cas, j’ai l’impression que le retour sur cette fonctionnalité est souvent négatif. D’une part, elle inquiète par le risque que les développements réalisés avant Java 9 ne fonctionnent plus et d’autre part, elle inquiète par le risque que les outils de l’écosystème Java (Maven, Gradle, IDE…) ne soient pas du tout prêts à ce grand changement. Je pense qu’il faudra beaucoup de temps pour que cette fonctionnalité arrive à percer, un peu comme les génériques de Java 5 à l’époque.

De mon côté, la nouveauté préférée reste REPL. C’est déjà un bon début, on peut facilement tester sans avoir à passer par la phase de compilation et d’exécution. Toutes les expérimentations faites pour la préparation de cette news ont été faites via ce REPL. Par contre, fournir une fenêtre AWT pour l’édition ce n’est pas terrible. Il aurait mieux valu se baser sur un éditeur du système par défaut.

La plus décevante c’est Jigsaw, non pas sur l’aspect technique, mais plus sur la mauvaise image de Java qu’elle a pu engendrer. Il ne faut pas oublier que la sortie de Java 9 a été repoussée à cause de cette fonctionnalité.

Avis 2 : Robin56, responsable Java sur Developpez.com
Comme Mickaël, quand on me parle Java 9, je pense modularité et donc je pense Jigsaw. Son intention est louable. Là où certaines versions ne révolutionnaient vraiment pas l’écosystème Java, je pense que ce n’est pas du tout le cas de l’arrivée de Java 9. Ceci va bousculer nos habitudes et aussi l’écosystème en général. On peut déjà remarquer les IDE et les outils de builds comme Maven devoir s’adapter à ces avancées.

Revers de la médaille, je crains aussi la montée en version sur Java 9. J’ai bien peur qu’elle se fasse dans la douleur. Rien que le planning de livraison de Java 9 témoigne des impacts de Jigsaw. Son retard de plusieurs mois prouve que cette évolution a des impacts majeurs sur Java. Gare aux projets qui vont migrer en Java 9, je crains qu’ils essuient les plâtres.

Dans tous les cas, la fonctionnalité que j’attends de voir avec l’arrivée de Java 9 est clairement le projet Jigsaw.

Avis 3 : bouye, rédacteur et modérateur Java sur Developpez.com
Mon avis rejoint celui de Mickael concernant les soucis engendrés par Jigsaw et de Robin56 pour le besoin de tout l'écosystème Java de s'adapter à ce nouveau mode de fonctionnement. Bien que n'étant pas un grand utilisateur de Maven, Graddle et co (surtout compte tenu des limitations de mon environnement de travail pro) je reconnais que ces outils sont désormais prédominants dans le monde Java et que le nouveau venu Jigsaw semble mal s'intégrer à l'existant. Je pense attendre que les IDE et outils soient un peu plus matures avant de tenter de porter mes projets vers le JDK9... ou, si je m'y lance, le premier jet sera sans doute sans support des modules.

À vous de jouer !!

Et vous :

  • Que pensez-vous de l’arrivée de Java 9 sur le marché ?
  • Quelles sont les évolutions où vous avez le plus d’attentes ?


Télécharger la nouvelle version de Java

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de grunt2000
Membre confirmé https://www.developpez.com
Le 22/09/2017 à 9:39
REPL permet à Java de se mettre à la hauteur de Python en terme d'accessibilité sur la ligne de commande.
Les enseignants vont bien l'apprécier : pour faire des démonstrations rapides de quel effet a telle instruction par rapport à telle autre, c'est très bien.

Parmi les progrès que j'ai vu, il y en a un qui passe inaperçu et qui va nous soulager pourtant : le passage en UTF-8 des fichiers de propriétés.
Beaucoup méconnaissaient l'utilitaire native2ascii et s'échinaient à entrer des \u0241 dans ces fichiers, s'épuisant, tout en les rendant illisibles.
C'en est fini de cela.
2  0 
Avatar de grunt2000
Membre confirmé https://www.developpez.com
Le 23/09/2017 à 7:58
Là je blâme parce que les conséquences elles sont déjà prévisibles.
Vu l'impact qu'il a, tout va devoir être refait.

Déjà : Maven, Eclipse, Tomcat, qui dysfonctionnent, et ce sont seulement les trois premiers que j'ai essayé.
Et c'est par transitivité que Maven est en cause : là, ce sont des artefacts populaires (apache commons-lang 2.x) qui cassent.

il ne suffit pas que les artefacts soient mis à disposition corrigés ni seulement Maven, il faut aussi que les éditeurs recompilent, re-packagent et relivrent tout à tout le monde. Ce n'est pas rien !
Tout en faisant des scripts de lancement qui disent :

Quelle est la version de Java que je trrouve sur le système ?
Si c'est la 8 ou la 7, je lance avec java maClasseMain
Si c'est la 9, je lance avec java maClasseMain --chargeça

Et ça pour la totalité du parc logiciel Java installé dans le monde. Tout ce qui a des annotations, de l'XML – et au bas mot 60% des applications du monde – plante d'autorité.

C'est loin d'être indolore à faire :
parce que si une application a été créée en 2013 avec un artefact-tierce-partie version 1.6 et ne fonctionne plus, c'est peut-être seulement l'artefact.tierce.partie version 3.7, bientôt disponible, qui sera compatible. Et voici 2 versions majeures de l'artefact à prendre en compte. Est-ce seulement possible ?

L'impact de Java 9, à mes yeux, il est très très lourd.
Que ce soit maintenant ou dans un an, ce travail restera à faire. Et il est pesant.

La preuve : Maven n'a pas été pris au dépourvu par Java 9 et sur le lien que tu indiques tu lis que ne fonctionnent pas à cet instant les plugins :
maven-ear-plugin, maven-ejb-plugin, maven-enforcer-plugin, maven-javadoc-plugin, maven-war-plugin
Le jour J, malgré toutes les milestones qu'ils ont certainement exoérimenté pour éprouver Maven face à Java 9, ils ne sont pas prêts.
Accordes-moi qu'au moins eux, ils l'auraient dû. Dans les dernières RC, Maven aurait du pouvoir être éprouvé, ses plugins majeurs rapidement rectifiés et redistribués, et ça n'a pas pu être le cas.
Maven n'a pas été pris au dépourvu par Java 9, donc, mais il a été et est encore dans l'incapacité de le suivre à cet instant.
C'est un présage sombre.

Ça donne l'étendue du chantier.
Alors qu'il aurait suffit de laisser Java continuer à fonctionner comme il le faisait, en chargeant toujours tout, et seulement sur un JAVA_OPTS paramétré par l'administrateur qui l'aurait vraiment voulu, dire : je me mets en mode "Je ne charge que le minimum."
Là on impose à toutes les applications de vivre sans oxygène. On l'impose. Et elles ne fonctionnent effectivement pas.
Qui a réussi à lancer quoi avec Java 9, aujourd'hui ? Il y a t-il seulement une application compilée avant Juillet 2017 qui fonctionne sans intervention ? Je me le demande.

C'est pour favoriser Python et C# cette belle démonstration ? Ce n'est pas parce que c'est Java nouvelle version que c'est bien et bien fait. Là, c'est cuisant.
C'est un mélange d'autoritarisme et de bêtise. Je l'écris, et je pense que je ne serai pas le seul dans les prochaines semaines à avoir cet avis.

C'est un mauvais choix qui ne tardera pas à être marquant dans le monde logiciel, et qui restera dans les annales.
2  0 
Avatar de yildiz-online
Expert confirmé https://www.developpez.com
Le 22/09/2017 à 22:51
Citation Envoyé par grunt2000 Voir le message
Bon... je vais faire Braillou-Braz, je ne pas content de cette arrivée d'un Java 9, peu exploitable.

...

Des génies.
Les problèmes que tu as cité sont tous issus de l'écosystème maven, pourquoi blâmer java 9?

Il y a d'ailleurs une page de status https://cwiki.apache.org/confluence/...ava+9+-+Jigsaw avec la liste des issues ouverts et des versions minimum requises.

Ce qui est génial c'est de migrer day one sans vérifier l'état des systèmes dépendant (vu les plugins maven en M1, c'est tout de même clair que ce n'est pas mature si on prend la peine de vérifier) et ensuite rejeter la faute
Une migration, ça se planifie: migration JRE, test, migration JDK test, migration bytecode, test, tout ça en un jour avec des dépendances même pas en RC, en esperant que ça passe crème, vraiment?...
1  0 
Avatar de sekaijin
Expert éminent https://www.developpez.com
Le 25/09/2017 à 8:42
Citation Envoyé par grunt2000 Voir le message
Là je blâme parce que les conséquences elles sont déjà prévisibles.
Vu l'impact qu'il a, tout va devoir être refait.

...
nous avons déjà eu ce genre de réaction par le passé. comme lorsqu'un acteur très connu a sorti une machine sans lecteur de disquette. ou lorsqu'on est passé de 32 a 64 bit.
oui ça change la donne mais il ne faut pas exagérer. lorsque ce sera digéré on dira. mais comment on a pu faire sans ça.

A+JYT
1  0 
Avatar de genamiga
Membre habitué https://www.developpez.com
Le 20/10/2017 à 13:37
Je travaille sur une application Java depuis des années.

J'ai commencé avec Java 6 et migrer vers Java 7 puis Java 8.
A chaque fois la compatibilité était parfaite (dans mon cas).

Ensuite petit à petit on réécrit du code pour profiter de la nouvelle version...en douceur.

Et là...C'est la rupture brutale...Pas de compatibilité...ça ne fonctionne pas du tout.

Je trouve qu'il est impératif qu'une application faite sous Java 8 fonctionne directement sous Java 9...c'est de la folie ce que Oracle a fait.
A la rigueur abandonner Java 6 et 7 mais pas le 8...c'est du grand n'importe quoi !

En plus vous avez vu le Oracle Java SE Public Updates...plus de maj après Sep 2018 pour Java 8.

Merci Oracle.
1  0 
Avatar de professeur shadoko
Membre expérimenté https://www.developpez.com
Le 06/03/2018 à 19:16
Citation Envoyé par grunt2000 Voir le message
Pour chaque ligne de commande lancée par Java 9 alors qu'elle était autrefois utilisée en Java 8, il pourra falloir rajouter un --add-modules avec des paramètres à sélectionner à chaque fois en fonction des manques constatés, empiriquement, ou à l'aide d'un outil d'analyse dédié, quand il existera.

Pour les composants tierce partie embarqués dans un logiciel et dysfonctionnant par des NoClassDefFoundError, si l'on ne peut les résoudre par un --add-modules inséré quelque-part, il faudra demander leur mise à jour à leur éditeur.
pas nécessaire de se taper la recherche des détails
il y a une possibilité de passer à --add-modules des paramètres comme ALL-DEFAULT, ALL-SYSTEM, ALL-MODULE-PATH.
1  0 
Avatar de genamiga
Membre habitué https://www.developpez.com
Le 09/03/2018 à 8:55
En suivant les recommandations de Oracle trouvées sur https://docs.oracle.com/javase/9/migrate/toc.htm#JSMIG-GUID-F640FA9D-FB66-4D85-AD2B-D931174C09A3, j'ai enfin une solution.

Pas très élégante et qui demandera sans doute de l'attention dans l'avenir.

Il faut récupérer les libs Java EE dont on a besoin sur Maven Central et les ajouter explicitement à son projet.

Alors cela fonctionne sous Java 8 et 9, et cela fonctionnera aussi quand Oracle supprimera ces libs d'une version future de Java.
1  0 
Avatar de deltree
Membre confirmé https://www.developpez.com
Le 09/03/2018 à 14:59
Citation Envoyé par yildiz-online Voir le message
C'est un peu normal, les librairies doivent pouvoir continuer à tourner sur des version de java plus anciennes, les libs qui requièrent absolument java 8 sont déjà rares, alors java 9...

Cependant la JEP238 (multi-release jar) devrait permettre de mitiger la situation, mais ça ajoute un coût de maintenance certain.

Sinon certaines libs s'y mettent, c'est le cas de SLF4j, hibernate validator, spring-boot entre autre,... donc c'est pas si mal.

Pour ma part, j'ai migré mon code perso, pas toujours une sinécure (activemq passe mal par exemple), mais globalement, c'est un changement très positif, d'un point de vue encapsulation et exposition des API, c'est une vraie avancée. Et si on l'aime pas, on peut toujours passer sur java 9 sans utiliser les modules...
Je fais justement du Spring boot en java 9, et on peut difficilement dire qu'ils s'y mettent, ils n'utilisent pas le fichier module-info, et ils proposent à la place d'ajouter des --add-modules pour que lancement fonctionne, c'est simplement compatible java 9 sans plus.

Pour slf4j oui il font une version java9 dans une branche spécifique, qui est encore en bêta.

Après je regrette pas mon choix du java 9, mais j'ai un peu l'impression d'essuyer les platres.
1  0 
Avatar de grunt2000
Membre confirmé https://www.developpez.com
Le 19/03/2018 à 12:39
L'introspection et la réflexion permettent à Java (et à d'autres langages) de déterminer durant l'exécution
quelles sont les variables membres ou méthodes de leur classe, et d'agir dessus directement.

Pour faire simple, tu pourrais écrire un programme de cette forme :
Code : Sélectionner tout
1
2
int mois = date.getMonth();
System.out.println("Nous sommes le mois de " + afficheurDeMois.invoke("nomMois" + mois));
Qui appellerait concrètement la méthode afficheurDeMois.nomMois3(), ce mois de Mars... bon ici, c'est très laid et très stigmatisé (parce que ce n'est pas tout à fait cela qu'il faut écrire), mais c'est l'idée.

Le problème que pose Java 9, c'est qu'autant l'on peut, lorsque l'on évite cette programmation, trouver des moyens de vérifier que ses programmes vont bien se restreindre à l'emploi de quelques packages que l'on a choisi, puisqu'ils sont explicitement nommés,
autant quand on est face à de la programmation reflexive, comment peut-on déterminer tout ce que l'on peut joindre avec ?

Un appel fait avec :
le_package_que_je_veux.la_classe_que_je_veux.la_methode_que_je_veux
où les trois-là sont des variables,
... peut appeler théoriquement n'importe quoi, car les appels sont construits dynamiquement, et peuvent tomber partout.
Dont à des endroits où en Java 9, il n'y aura "plus rien" au démarrage de la JVM.
1  0 
Avatar de sekaijin
Expert éminent https://www.developpez.com
Le 20/03/2018 à 9:49
Supposons que tu ais une classe MyClass avec la méthode privée aMethod

tu as un objet de cette class
Code : Sélectionner tout
MyClass obj = new MyClass();
et tu aimerais pouvoir écrire
Code : Sélectionner tout
obj.aMethod();
Mais comme elle est privé tu ne peux pas.
l'introspection te permet de connaitre toutes les méthodes de ta classe, au moment de l'exécution.

quelque chose comme ça (pseudo code)
Code : Sélectionner tout
1
2
3
4
List<Method> lst = obj.getClass().getListOfMethods();
for (Method m : lst) {
   system.out.println(m.getName());
}
sur chaque méthode tu peux connaitre son nom ses restrictions ses paramètres son type de retour
mais tu peux surtout l'appeler. (pseudo code)
Code : Sélectionner tout
1
2
Method m = obj.getClass().getMethod("aMethod");
system.out.println(m.invoke(obj)); //ce qui revient à faire obj.aMethod()
Si tu fait ça tu vas obtenir une exception Illegal Access car la méthode est privé et tu n'y a pas accès.

quand je parle de tricher c'est que java te permet tout de même de faire cet appel en passant outre les restrictions quelque chose qui ressemblerait à ça (pseudo code)
Code : Sélectionner tout
1
2
Method m = obj.getClass().getMethod("aMethod");
system.out.println(m.invokeIgnoreRestrictions(obj)); //ce qui revient à faire obj.aMethod() alors même qu'elle est privée.
j'appelle ça tricher car si le développeur à mis la méthode privé c'est pour qu'elle ne soit pas accessible.

la modularisation va changer la donne en ce sens que si la classe est dans un package qui n'est pas exporté par le module
non seulement tu ne pourras pas passer outre la restrictions mais tu ne verras même pas la méthode.

c'est déjà vrais avec les modules OSGi
tu définis une interface publique et une implémentation privée

dans le jar contenant l’implémentation via l'introspection tu peux faire ce que nous venons de décrire

mais dans un autre jar qui accède à l'implémentation via un service tu ne vois que la partie exporte (l'interface)
si via l'introspection tu cherche à accéder à l'implémentation tu tombe sur une classe appelée Proxy qui ne contient aucune donnée et aucune autre méthodes que celles de l'interface. tu n'a donc accès à rien.

ce qui est un gage de sécurité.

A+JYT
1  0