JDK 25 Arrive : API Valeurs Stables et Nouveautés Clés

Java continue d’évoluer, et la prochaine version JDK 25 est riche en mises à jour conçues pour faciliter le codage et accélérer l’exécution des applications. Une nouvelle fonctionnalité marquante est l’API de valeurs stables, qui apporte des avantages significatifs en termes de performance, notamment lors du démarrage des applications.

Cette version simplifie également la structure du code pour les débutants, améliore la sécurité et les processus d’initialisation, rationalise l’utilisation des modules et dope la performance des types de données fondamentaux comme les chaînes de caractères (Strings). Plongeons dans les points saillants.

Booster la performance avec l’API de valeurs stables

L’un des objectifs principaux de JDK 25 est de s’attaquer à la performance au démarrage des applications. Souvent, la mise en place d’objets complexes nécessaires très tôt peut ralentir les choses. Traditionnellement, les développeurs utilisent des champs final pour la performance (ils ne sont initialisés qu’une seule fois et sont très rapides), mais cela exige de les configurer immédiatement. L’initialisation paresseuse (lazy initialization) (ne configurer quelque chose que lorsque c’est nécessaire pour la première fois) permet d’économiser du temps de démarrage, mais peut impliquer des vérifications compliquées et moins performantes chaque fois que la valeur est accédée.

La nouvelle API de valeurs stables (Stable Values API), introduite via JEP 502, offre une solution astucieuse. Elle permet de définir une valeur qui peut être définie au plus une seule fois. Imaginez-la comme une variable qui commence vide mais qui, la première fois que vous demandez sa valeur, la calcule puis la verrouille pour toujours, rendant les accès ultérieurs aussi rapides qu’un champ final. Cette initialisation est gérée de manière sûre, même lorsque différentes parties de votre programme s’exécutent simultanément (thread-safe).

Cette approche permet à la Machine Virtuelle Java (JVM) de réaliser des optimisations généralement réservées aux champs final, mais avec la flexibilité d’une configuration différée.

Le cœur de cette API est la classe StableValue. Vous en créez une, et sa valeur ne peut être définie qu’en appelant la méthode orElseSet(). Si la valeur n’a pas encore été définie, le code que vous fournissez dans orElseSet() s’exécute, définit la valeur et la retourne. Si elle est déjà définie, la valeur existante est retournée instantanément.

Voici un aperçu simple de son fonctionnement :

class OrderController {
    private final StableValue<logger> logger = StableValue.of();

    Logger getLogger() {
        return logger.orElseSet(() -> Logger.create(OrderController.class));
    }
}</logger>

Ce schéma simplifie le code courant pour obtenir une ressource (comme un logger) dont vous n’avez besoin qu’une seule fois, mais pas nécessairement dès la création de l’objet. Il remplace des schémas d’initialisation paresseuse manuels plus complexes par un mécanisme clair, thread-safe et optimisé. L’API inclut également des extensions pour gérer des listes et des fournisseurs de valeurs stables.

Engrenages abstraits représentant l'optimisation et l'efficacité dans le développement Java

Rendre Java plus simple et plus flexible

JDK 25 ne concerne pas seulement la performance sous le capot ; il introduit également des changements qui simplifient l’expérience de codage, en particulier pour les nouveaux venus.

Démarrages plus simples : Méthodes main d’instance et fichiers source compacts

Écrire votre premier « Hello, World! » en Java nécessitait traditionnellement de comprendre les classes, les méthodes statiques et les importations explicites. JEP 512 vise à abaisser cette barrière avec les Fichiers source compacts et les Méthodes main d’instance.

Désormais, vous pouvez écrire des programmes incroyablement simples comme celui-ci :

void main() {
    IO.println("Hello, World!");
}

Le lanceur Java est plus intelligent et peut rechercher une méthode main d’instance (void main()) s’il ne trouve pas la méthode main statique traditionnelle. Cela permet des programmes à fichier unique beaucoup plus concis.

S’y ajoute la nouvelle classe java.lang.IO, qui fournit des opérations d’entrée/sortie de base sans nécessiter d’instructions d’importation explicites dans ces fichiers compacts, simplifiant encore les choses.

Corps de constructeur flexibles

Les constructeurs, qui configurent de nouveaux objets, ont traditionnellement eu une règle stricte : la toute première chose qu’ils doivent faire est d’appeler un autre constructeur (en utilisant super(...) ou this(...)). JDK 25 introduit les Corps de constructeur flexibles, permettant aux développeurs d’inclure des instructions avant cet appel.

Cela peut sembler mineur, mais cela améliore considérablement la sécurité et l’initialisation. Cela vous permet d’effectuer des vérifications ou des configurations simples pour les champs avant de passer ces valeurs à un autre constructeur, garantissant que les valeurs utilisées par super() ou this() sont déjà dans un état sûr.

Importations de modules simplifiées

Le système de modules de Java aide à organiser les grandes applications, mais l’importation de packages à partir de modules pouvait encore entraîner de longues listes d’instructions d’importation. JEP 511 introduit les Déclarations d’importation de module, vous permettant d’importer tous les packages exportés d’un module avec une seule déclaration claire. Cela réduit l’encombrement et rend la gestion des dépendances dans les projets modulaires beaucoup plus simple.

Opérations sur les chaînes de caractères plus rapides

Les chaînes de caractères (Strings) sont fondamentales pour presque tous les programmes Java, et JDK 25 apporte également un gain de performance ici. L’implémentation de String::hashCode, qui est utilisée fréquemment (par exemple, lors de l’utilisation de Strings comme clés dans les cartes/maps), a été optimisée. Ce changement peut entraîner des améliorations de vitesse notables dans les opérations qui dépendent fortement des recherches de chaînes, en particulier dans les applications utilisant des maps immuables.

En parlant d’efficacité et de sécurité dans les applications, la gestion de l’authentification utilisateur peut être complexe. Des solutions comme l’authentification sans mot de passe (utilisant des passkeys, des OTP) offertes par des fournisseurs tels que MojoAuth peuvent rationaliser les processus de connexion utilisateur pour les applications web et mobiles, améliorant à la fois la sécurité et l’expérience utilisateur.

Développeur travaillant sur un ordinateur portable, représentant le développement Java moderne avec les nouvelles fonctionnalités de JDK 25

Perspectives

Alors que Java entre dans sa quatrième décennie, il continue d’évoluer avec des fonctionnalités comme l’API de valeurs stables qui offrent des avantages concrets en termes de performance et de productivité pour les développeurs. JDK 25 jette également les bases et affine les projets en cours tels que l’API Foreign Function and Memory et Structured Concurrency, promettant des moyens encore plus puissants et faciles d’écrire des applications complexes à l’avenir.

Cette dernière version renforce la position de Java en tant que plateforme robuste et moderne pour les entreprises, soutenue par une communauté dynamique et un vaste écosystème. Pour les entreprises axées sur la gestion efficace des identités et des accès utilisateurs, des solutions comme les plateformes CIAM (Customer Identity and Access Management) offrent des outils complets.