Leçons

Nous allons au‑delà de la sérialisation de base en Java : lorsque l’automatisme de Serializable ne suffit pas, le contrat manuel Externalizable avec les méthodes writeExternal/ readExternal vient à la rescousse. Dans ce cours, nous expliquons comment contrôler entièrement le format des données, réduire la taille des fichiers et maintenir la rétrocompatibilité, nous comparons avec les flux ObjectOutputStream/ ObjectInputStream, et nous montrons des exemples, des avantages/inconvénients et des erreurs typiques (constructeur public sans paramètre obligatoire, ordre d’écriture/lecture, etc.).

Dans ce cours, nous voyons comment influencer le processus de sérialisation et de désérialisation en Java à l’aide des méthodes writeReplace et readResolve : pourquoi remplacer un objet par un proxy, comment préserver un singleton, quoi faire avec des objets immuables, et comment cela se rapporte à writeObject/ readObject. Pratique pas à pas, schéma du flux des opérations et analyse des erreurs typiques.

Guide pratique de la sérialisation sécurisée en Java : en quoi la désérialisation provenant de sources non fiables est dangereuse, comment se protéger à l’aide de ObjectInputFilter, du mot-clé transient, d’un serialVersionUID explicite, de la vérification des types via instanceof et de formats d’échange alternatifs (JSON/Proto). À l’intérieur — des exemples de code parlants, le filtrage des classes autorisées et l’analyse des erreurs typiques.

Dans cette leçon, nous expliquons comment Java réalise une sérialisation profonde d’un graphe d’objets : ce qui arrive aux champs de référence, pourquoi tous les objets imbriqués doivent implémenter Serializable, comment éviter NotSerializableException, et dans quels cas le modificateur transient aide. À l’aide d’exemples, nous montrerons la sérialisation/désérialisation d’objets avec imbrication, collections et références cycliques, et nous analyserons aussi les erreurs typiques liées à serialVersionUID et aux grands graphes d’objets.

Comment Java sérialise des structures de données complexes : des collections imbriquées et des hiérarchies d’héritage jusqu’aux graphes d’objets cycliques. Nous verrons pourquoi la sérialisation de Map<String, List<Book>> fonctionne, comment les types réels des descendants sont conservés dans List<Animal>, ce que fait le mécanisme de références en présence de cycles, et quels écueils peuvent survenir. Parlons du rôle de ObjectOutputStream/ ObjectInputStream, des méthodes writeObject/ readObject, du champ serialVersionUID et du modificateur transient.

Nous analysons ce que sont les références cycliques dans les graphes d’objets, en quoi elles sont dangereuses pour la sérialisation et comment les gérer. Il est montré comment les flux standard de Java — ObjectOutputStream/ ObjectInputStream — suivent automatiquement les objets déjà rencontrés et écrivent des références (handles), empêchant StackOverflowError. Nous examinerons les écueils de la sérialisation personnalisée ( writeObject/ readObject, defaultWriteObject/ defaultReadObject), ainsi que des stratégies de contournement des cycles en JSON : annotations @JsonIdentityInfo, @JsonBackReference/ @JsonManagedReference, exclusion de champs via transient et utilisation d’identifiants.

Comment Java conserve et restaure l'identité des objets lors d'une sérialisation binaire : pourquoi l'équivalence via a. equals( b) n'est pas l'identité ( a == b), comment ObjectOutputStream/ ObjectInputStream suivent le graphe d'objets et écrivent des « références partagées » au lieu de doublons, pourquoi cela fonctionne correctement avec les cycles, et comment les méthodes writeReplace() et readResolve() peuvent influer sur l'identité finale. Analyse avec exemples : cycles, références partagées, pratique et erreurs typiques.

Dans ce cours, nous passons en revue les problèmes les plus fréquents lors de la sérialisation des collections : de java.io.NotSerializableException (lorsque les éléments n’implémentent pas Serializable) et des pièges des génériques avec ClassCastException jusqu’aux incompatibilités de versions de classes via serialVersionUID. Nous parlerons des nuances des collections immuables ( List.of(), Set.of(), Map.of()), du comportement des champs transient/ static, ainsi que des performances et de la taille des fichiers, où l’écriture en flux et la compression ( GZIPOutputStream) peuvent aider. Vous obtiendrez des conseils pratiques, des extraits de code et des recommandations pour une désérialisation sûre ( readObject/ writeObject).

Dans ce cours, nous analysons les risques de la sérialisation binaire en Java : pourquoi la désérialisation depuis des sources non fiables est dangereuse (chaînes de « gadget chain », RCE), quels sont les risques des méthodes spéciales comme readObject et readResolve, et comment se protéger (liste blanche/whitelisting, abandon au profit de JSON/ XML, bibliothèques plus sûres comme Jackson). Nous examinerons en détail la compatibilité entre versions de classes et le rôle du champ serialVersionUID, le comportement en cas de InvalidClassException, les limites de transient/ static, les performances, ainsi que les bonnes pratiques et erreurs typiques.

Nous analysons comment l’effacement des types ( type erasure) influe sur la sérialisation des collections génériques : pourquoi, à l’exécution, List<String> et List<Integer> sont la même ArrayList, ce qui est exactement écrit et lu via ObjectOutputStream/ ObjectInputStream, d’où viennent ClassCastException et les avertissements de casts unchecked. Nous montrerons des exemples avec des collections imbriquées, Map/ Set, mentionnerons Gson/ Jackson, et formulerons des pratiques de désérialisation sûre.

Examinons comment faire évoluer des classes sérialisables sans casser les données : pourquoi figer serialVersionUID, comment la JVM vérifie la compatibilité, quels changements sont sûrs (ajout/suppression de champs) et lesquels sont critiques (changement de type, déplacement d’une classe vers un package). Nous montrerons le rôle de transient/ static, des techniques de sérialisation personnalisée via writeObject/ readObject, la différence entre la sérialisation binaire et XML/JSON, des stratégies pour assurer la compatibilité et des erreurs typiques (par exemple, InvalidClassException).

Comment faire évoluer en toute sécurité des classes sérialisables en production : ce qui se passe lors de la modification des champs et des types, comment fonctionne la version de la classe via serialVersionUID, quand la modifier et quand la conserver, comment appliquer une migration « paresseuse » via readObject/ readFields et une conversion « in-place », et quelles techniques avancées existent comme ObjectInputStream.readClassDescriptor(). Nous examinerons un scénario pratique complet avec deux versions de la classe et les erreurs typiques, y compris les pièges InvalidClassException.