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

Le , par Mickael Baron, Responsable Java
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 importante. 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 sur 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 apparu 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ée 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’attente ?


Télécharger la nouvelle version de Java


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse

Avatar de joel.drigo joel.drigo - Modérateur https://www.developpez.com
le 22/09/2017 à 4:19
Salut,

Je suis décu que la JEP 301 ne soit finalement pas implémentée dans Java 9. J'attendais ces évolutions avec impatience.

En revanche, les nouveautés de la classe Desktop sont bienvenues, en particulier pour l'intégration MacOSX.
Avatar de grunt2000 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.
Avatar de hotcryx hotcryx - Membre émérite https://www.developpez.com
le 22/09/2017 à 10:21
Grunt >> "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."

Tu sais s'il y a moyen de tester si un emoji est installé sur un device?
Comme les emoji ont un encoding utf8...
Avatar de esperanto esperanto - Membre confirmé https://www.developpez.com
le 22/09/2017 à 14:20
Citation Envoyé par Mickael Baron Voir le message
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.
Dommage que ça ne s'applique qu'à la version de Java, pas des modules ou d'autres librairies (un comble quand on sait que la nouveauté principale est la modularité): je cherchais justement un moyen d'avoir dans le même JAR le même plugin adapté à deux versions d'une application principale. Bon, tant pis.

Citation Envoyé par grunt2000 Voir le message
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.
C'est vrai, encore que depuis pas mal de temps je faisais ça avec jjs. Bon d'accord ça oblige à faire du javascript et pas du java. Mais d'un autre côté, si Java conserve toutes ses contraintes en mode REPL (comme l'obligation de typer toutes les variables) ça en diminue quand même un peu l'intérêt.

Citation Envoyé par grunt2000 Voir le message
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.
Intéressant mais un peu tardif. Tant qu'à faire, pourquoi ne pas remplacer le vieux format plat des fichiers properties par un format hiérarchique, genre JSON ou YAML?
Et puis contrairement à ce qu'écrit Oracle ici, je connais pas mal de gens qui sous prétexte de travailler seulement en français+anglais laissent les fichiers Properties en ISO-8859-1 dans les jar, ce qui entraînera fatalement des erreurs au moment de basculer à Java 9.

Citation Envoyé par hotcryx Voir le message
Tu sais s'il y a moyen de tester si un emoji est installé sur un device?
A priori c'est plutôt au niveau des polices de caractères : si les emoji sont des caractères, alors chacun doit être présent dans toutes les polices de caractère, sauf si l'outil génère des changements de police à la volée.

Citation Envoyé par hotcryx Voir le message
Comme les emoji ont un encoding utf8...
oui mais ils ne sont pas dans le BMP, donc en UTF-8 ils prendront 4 positions! On passe donc à UTF-8 précisément au moment où il est susceptible de devenir obsolète même dans les pays où on n'utilise que le latin sans accent...
Avatar de adiGuba adiGuba - Expert éminent sénior https://www.developpez.com
le 22/09/2017 à 14:52
Citation Envoyé par esperanto Voir le message
je connais pas mal de gens qui sous prétexte de travailler seulement en français+anglais laissent les fichiers Properties en ISO-8859-1 dans les jar, ce qui entraînera fatalement des erreurs au moment de basculer à Java 9.
Apparemment le chargement d'un fichier Properties repasse en ISO-8859-1 si la lecture en UTF-8 échoue, donc çà ne devrait pas poser trop de problèmes.
https://docs.oracle.com/javase/9/int...2-82006A7A14C7
Avatar de esperanto esperanto - Membre confirmé https://www.developpez.com
le 22/09/2017 à 15:00
Citation Envoyé par adiGuba Voir le message
Apparemment le chargement d'un fichier Properties repasse en ISO-8859-1 si la lecture en UTF-8 échoue, donc çà ne devrait pas poser trop de problèmes.
https://docs.oracle.com/javase/9/int...2-82006A7A14C7
Oui j'avais lu puisque c'était précisément ce lien que je citais.
Mais un basculement automatique ce n'est pas sans danger: tant que les gens pourront éditer le fichier à la main, il se produira toujours des cas où, en l'ouvrant avec un éditeur mauvais ou mal paramétré, on se retrouvera au milieu du document avec un mauvais caractère entraînant le basculement de l'encodage pour l'ensemble du document.
Avatar de sekaijin sekaijin - Expert éminent https://www.developpez.com
le 22/09/2017 à 17:53
Une des questions récurent auxquelles j'ai droit est la remise en cause de la modularité de OSGi face à jigsaw.

à mon avis la modularité dans java9 est résolue à la compilation.
tu définis des modules et leurs dépendances. Puis tu compile et tu lie les modules ensemble pour obtenir une JVM ad-hoc.
Avec OSGi (karaf, felix, equinoxe...) la résolution est dynamique elle se fait à l'exécution. soit lorsque le module est déployé (import) soit lorsqu'il est exécuté (dynamic-import).

l'un et l'autre ne sont pas contradictoire mais complémentaires.
On peut très bien imaginer une karaf écrite sous forme de modules java9 pour obtenir un noyau minimal. les ajouts dynamiques de OSGi étant relégués à l'exécutions.

Je pense qu'une évolution de OSGi devra décidé de l'interprétation à faire lors du déploiement de modules java9 dans un conteneur.
l'entête du module contient les informations import/export, mais pas de notion de version. tout comme aujourd'hui lorsqu'un bundle importe un package sans spécifier de version, c'est la version la plus récente disponible qui est lié.

J'ajoute que l'alliance OSGi s'étonne de l'absence de version dans les import/export et de la dissymétrie des import/export. l'expérience de l'alliance dans le domaine à montré qu'un système symétrique était beaucoup plus facile à implémenter et à gérer. importer des modules et exporter des packages n'est pas pour l'alliance une bonne chose. un autre problème noté est l'impossibilité des faire évoluer la classe module-info.java. le fichier meta-info des jar laissait la possibilité d'ajouter des clefs qui n'était interprétées que par ceux qui s'y intéressait et était ignorées par la JVM standard. Les infos du module sont compilé dans une classe module-info qui n'est pas extensible qui ne peut être dérivée et qui ne supporte pas les annotations.
A+JYT
Avatar de adiGuba adiGuba - Expert éminent sénior https://www.developpez.com
le 22/09/2017 à 18:25
Citation Envoyé par esperanto Voir le message
tant que les gens pourront éditer le fichier à la main, il se produira toujours des cas où, en l'ouvrant avec un éditeur mauvais ou mal paramétré, on se retrouvera au milieu du document avec un mauvais caractère entraînant le basculement de l'encodage pour l'ensemble du document.
En même temps un fichier mal encodé peut déjà poser des problèmes, même sous Java 8.
Je ne vois pas trop le problème avec çà.
Avatar de grunt2000 grunt2000 - Membre confirmé https://www.developpez.com
le 22/09/2017 à 19:41
Bon... je vais faire Braillou-Braz, je ne pas content de cette arrivée d'un Java 9, peu exploitable.

maven-enforcer-plugin:1.4.1 bloque toute compilation par Maven des projets Spring boot (la dépendance Apache commons-lang2 est responsable de cet incident, d'après ce que j'ai compris, traquez-là au plus tôt),
Ailleurs, des tests unitaires s'arrêtent en disant : "On ne veut plus continuer, JAXB n'existe plus !". Sans doute, il me faudra bidouiller le paramétrage des plugins surefire et failsafe. Et vous aussi. Et lui aussi, et eux aussi, et ...
Merci pour le boulot additionnel !

Je ne comprends pas la démarche,

Il n'auraient pas pu faire un fonctionnement de Java 9 normal d'abord
et génial ensuite, seulement sur demande ?

Parce que le mode génial empêche de lui faire faire fonctionner quoi que ce soit à cet instant.

Absolument rien ne démarre avec Java 9.
Je suis passé du Java 1.2 à mes débuts à Java 9 aujourd'hui. Et j'ai jamais vu ça. On est pas à 99% - 100% de bon fonctionnement comme on l'a souvent eu,
on est à quoi ? 10, 20% des trucs qui tournent avec sans manipulation ? Et 40% avec ? Tous les éditeurs cavalent pour essayer de trouver comment répondre aux plantages induits par Java 9.
S'ils ont de la chance, une communication sur un forum suffira. Sinon : repackaging et relivraison pour tout le monde.

Tout le monde logiciel, version +1 de tous les artefacts du monde... et de leurs dépendances... et sous dépendances.
Merci Java ! Y avait vraiment besoin de ça !

Des génies.
Avatar de BBric BBric - Membre du Club https://www.developpez.com
le 22/09/2017 à 21:26
Sur un petit programme je suis passé de 60/75Mo d'occupation mémoire par la JVM en Java8, à 14Mo en Java9; mais je n'ai pas vu de différences sur le temps de lancement.
Quand on passe son code en modules ça permet de mieux appréhender sa structure globale j'ai trouvé, notamment à cause des dépendances circulaires.
Sinon REPL et les fabriques de collections me parlent bien.
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -