Java

Sommaire

• Sommaire
• 1. Définition Wikipedia [source]
• 2. Spring
• 3. Kotlin
• 4. Immutabilité

• 5. Version et évolution

  • 5.1. Timeline: Java 1.8 à aujourd'hui

  • 5.2. Changelog

    • 5.2.1. Ajout de la version Java 1.8 [digitalocean]
    • 5.2.2. Ajout de la version Java 9
    • 5.2.3. Ajout de la version Java 10
    • 5.2.4. Ajout de la version Java 11
    • 5.2.7. Ajout de la version Java 14
    • 5.2.8. Ajout de la version Java 15
    • 5.2.9. Ajout de la version Java 16
    • 5.2.10. Ajout de la version Java 17
    • 5.2.11. Ajout de la version Java 18
    • 5.2.12. Ajout de la version Java 19
    • 5.2.13. Ajout toujours en preview

1. Définition Wikipedia [source]

Java est un langage de programmation orienté objet créé par James Gosling et Patrick Naughton, employés de Sun Microsystems, avec le soutien de Bill Joy en 1982, présenté officiellement le 23 mai 1995 au SunWorld

La société Sun a été ensuite rachetée en 2009 par la société Oracle qui détient et maintient désormais Java.

Une particularité de Java est que les logiciels écrits dans ce langage sont compilés vers une représentation binaire intermédiaire qui peut être exécutée dans une machine virtuelle Java (JVM) en faisant abstraction du système d'exploitation.

2. Spring

En Java, Spring comme Java EE permettent depuis longtemps de réaliser des web services. Néanmoins, dans le cas de Java EE, cela nécessite le recours à un serveur d'application certifié, tel que WildFly, alors qu'en Spring, un simple serveur web (léger) tel que Tomcat suffit.

Déployer une API de services sur un serveur d'applications Java EE est complexe : configuration, packaging, sélection des modules… cela nécessite du temps et de l'expertise. A l'heure actuelle, Java EE avance lentement vers la voie du cloud (trop lentement, serait-on tenté de dire).

De son côté Spring propose Spring Boot, une approche module particulièrement rapide et efficace pour créer une API de web services. En quelques lignes de code, avec un (tout) petit projet Maven/Gradle, on obtient un .jar directement exécutable. Tout est compris, les briques du serveur web dont vous avez besoin, et rien d'autre. Vous pouvez très simplement utiliser les frameworks dont vous avez besoin (Hibernate, par exemple, ou n'importe quelle brique du Spring classique), Spring vous package le tout en un rien de temps.

3. Kotlin

Kotlin est simplement une dépendance et un plugin pour Maven/Gradle. C'est un langage agréable, compact et facile à utiliser qui supprime toute la lourdeur syntaxique (par opposition au "syntactic sugar") que Java fournit.

À partir de la version 5.0.0, Kotlin bénéficie d'un support de première classe de la part de Spring, ce qui offre les mêmes garanties que Java en termes de robustesse du code.

Kotlin est interopérable par conception, il s'intégrer en douceur à n'importe quelle bibliothèque Java déjà existante, ce qui offre un véritable liberté de choix.

Ainsi, Kotlin fonctionne bien avec Spring, qui fournit une grande partie des fonctionnalités standard pour les applications Web, en particulier Spring Boot.

Kotlin a une syntaxe beaucoup plus compacte et son système de type permet un code beaucoup plus robuste grâce à la sécurité nulle (null safety), aux classes scellées (sealed classes) et aux notions d'immutabilités.

4. Immutabilité

Il est aussi possible d'utilisé la bibliothèque Java Immutables ou la fonctionnalité Java des Record pour atteindre cette notions d'immutabilité, permettant de facilement implémenté des valeurs (value object) associés au Domain Driven Design (DDD).

Ainsi, une requête HTTP doit être considérée comme une valeur car celle-ci doit être immutable : si nous en modifions le moindre caractère ce n'est plus la même requête et le comportement engendré sur le serveur pourrait être radicalement différent. Plus important, l'identité d'une requête HTTP nous importe peu, seul son contenu est utile. Pour preuve, le contenu d'une requête provoque la génération d'une réponse qui est souvent mise dans un système de cache. Une autre requête avec le même contenu se verra retourner la même réponse.

5. Version et évolution

5.1. Timeline: Java 1.8 à aujourd'hui

Les cycles de publication jusqu'a la version 1.8 durait environs 3 à 5 ans. Les nouvelles versions de Java sortent désormais tous les 6 mois.

Les projets "legacy" d'entreprises sont souvent bloqués à Java 1.8, plus rarement avec des versions antérieurs. Pourquoi? La réponse est un mélange de problèmes pratiques (mise à niveau de vos outils, bibliothèques, frameworks) et de problèmes politiques:

• les outils de build (Maven, Gradle etc.) et certaines librairies avaient initialement des bugs avec les versions supérieurs à Java 8 et nécessitaient des mises à jour;
• Oracle a modifié le système de licences en 2019, ce qui à provoqué la confusion des utilisateurs. Jusqu'à Java 1.8, seul les versions JDK d'Oracle étaient disponibles et il n'y avait pas à ce soucier des licences (sauf cas à la marge);
• les entreprises ont pour politique de n'utiliser que les versions LTS et de compter sur leurs fournisseurs de systèmes pour leur fournir ces versions, ce qui prend du temps.

Si vous démarrez un nouveau projet, vous pouvez, sans hésitation, utiliser Java 17 (LTS) ou plus récente.

Pour des fonctionnalités actualisées sur une version antérieur, l'utilisation de Kotlin permet de cibler un JDK 1.8 (d'anciennes versions permettent de l'utiliser à partir d'un JDK 1.6).

5.2. Changelog

5.2.1. Ajout de la version Java 1.8 [digitalocean]

Essentiellement, toutes les fonctionnalités du langage Java 1.8 et antérieur fonctionnent également dans les versions supérieur (tel que Java 19). Ces fonctionnalités forment une base et comprennent:

• JAVA 1.7 Generic et Diamond Operator
• methodes d'interfaces default et static

• functional Interfaces et lambda expressions, permettent de traiter les fonctions comme un argument de méthode ou le code comme des données (et qui permettent de s'affranchir de l'écriture de anonymous inner class pour l'implémentation)

  //Anciennement
  for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
  }
  Thread monThread = new Thread(new Runnable() {
    @Override
    public void run(){
      System.out.println("Mon traitement ");
    }
  });
  
  //A partir de Java 1.8
  list.forEach(System.out::println);
  Thread monThread = new Thread(() -> { System.out.println("Mon traitement"); });

• Stream API, prendre en charge les opérations séquentiels ou parallèles de style fonctionnel sur des flux d'éléments

  List<String> list = Arrays.asList("one", "two");
  list.stream()
    .filter(name -> name.startsWith("o"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

• Iterable Interface

  • forEach se focus sur la partie
• Optional Le but de la classe est de fournir une solution au niveau du type pour représenter des valeurs facultatives au lieu de références nulles

• Java Time API

  • LocalDate
  • LocalDateTime
  • Instant

• Collections API

  • Collection spliterator()

  • Map

    • ajout de Map replaceAll(), compute(), merge();
    • amélioration des performances pour la classe HashMap avec Key Collisions

• Concurrency API improvements

  • ConcurrentHashMap
  • CompletableFuture

5.2.2. Ajout de la version Java 9

• Collections helper de création

  • of

    List<String> list = List.of("one", "two", "three");
    Set<String> set = Set.of("one", "two", "three");
    Map<String, String> map = Map.of("foo", "one", "bar", "two");

• nouvelles méthodes Streams

  • takeWhile
  • dropWhile
  • iterate

• optional

  • ifPresentOrElse

• interfaces

  • méthodes privées
• diamond operator pour anonymous inner class
• JShell, shell JAVA avec résultat immédiat
• projet Jigsaw: Modules JAVA et Multi-Release Jar Files

5.2.3. Ajout de la version Java 10

• mot-clef var, variable locale s'appliquant seulement au scope d'une méthode, toujours fortement typée

5.2.4. Ajout de la version Java 11

• Différentes méthodes Strings et Files

  "Marco".isBlank();
  "Mar\nco".lines();
  "Marco  ".strip();
  
  Path path = Files.writeString(Files.createTempFile("helloworld", ".txt"), "Hi, my name is!");
  String s = Files.readString(path);

• execution de fichier source: exécution des fichiers source Java sans avoir à les compiler au préalable. Un pas vers la scripting.

• inférence de type variable local (var) pour les paramètre de fonction lambda

  (var firstName, var lastName) -> firstName + lastName

• HTTPClient, implémentation intégré au JDK en version final
• Flight Recorder
• No-Op Garbage Collector

5.2.7. Ajout de la version Java 14

• nouvelle expression switch en version final

  • retour possible
  • synthaxe lambda possible
• NullPointerExceptions plus précis sur les causes

• Garbage Collectors

  • Concurrent Mark Sweep (CMS) Garbage Collector supprimé

5.2.8. Ajout de la version Java 15

• Text-Blocks / Multiline Strings en version final

  String htmlBeforeJava13 = "<html>\n" +
              "    <body>\n" +
              "        <p>Hello, world</p>\n" +
              "    </body>\n" +
              "</html>\n";
  
  String htmlWithJava15 = """
                <html>
                    <body>
                        <p>Hello, world</p>
                    </body>
                </html>
                """;

• Garbage Collectors

  • ZGC, Z Garbage Collector en version final

5.2.9. Ajout de la version Java 16

• Pattern Matching for instanceof

  //before
  if (obj instanceof String) {
    String s = (String) obj;
    s.substring(1)
  }
  
  //after
  if (obj instanceof String s) {
    s.substring(1)
  }

• Unix-Domain Socket Channels

• records en version finale, sont un nouveau type de classe dans le langage Java (record class), qui proposent une syntaxe compacte pour la déclaration de classes aux fonctionnalités restreintes qui agrègent des valeurs de manière immuable

  //before
  final class Point {
    public final int x;
    public final int y;
  
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
  
    // implementations of equals, hashCode, toString and getter needed
  }
  
  //after
  record Point(int x, int y) { }

5.2.10. Ajout de la version Java 17

• Sealed Classes en version final, sont des classes et interfaces qui limitent les classes qui peuvent les étendre/implémenter

5.2.11. Ajout de la version Java 18

• UTF-8 par défaut
• jwebserver, web server basic

5.2.12. Ajout de la version Java 19

5.2.13. Ajout toujours en preview

• Pattern Matching pour switch
• Virtual Threads
• Foreign Function
• Memory API
• Structured Concurrency
• Vector API