Solutions modernes : JSON et Protocol Buffers
Remplacez la sérialisation Java par JSON avec Jackson et Protocol Buffers pour une persistance portable et sécurisée.
Solutions modernes : JSON et Protocol Buffers est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Pourquoi remplacer la sérialisation Java ?
La sérialisation Java est limitée à la JVM, verbeuse, lente et présente un risque de sécurité. Les applications modernes préfèrent JSON, lisible par les humains et indépendant du langage, ou les tampons de protocole, compacts, rapides et fondés sur un schéma.
Jackson : la bibliothèque JSON de facto
ObjectMapper de Jackson convertit les objets en chaînes JSON et inversement. Ajoutez com.fasterxml.jackson.core:jackson-databind à votre projet.
ObjectMapper mapper = new ObjectMapper();
User user = new User("Alice", 30);
String json = mapper.writeValueAsString(user);
System.out.println(json); // {"name":"Alice","age":30}
User restored = mapper.readValue(json, User.class);Personnaliser Jackson avec des annotations
Utilisez @JsonProperty, @JsonIgnore, @JsonAlias et @JsonFormat pour contrôler la sérialisation sans modifier les noms de champs dans votre modèle.
public class Product {
@JsonProperty("product_name")
private String name;
@JsonIgnore
private String internalCode;
@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate releaseDate;
}Modules Jackson : prise en charge de Java Time
Enregistrez JavaTimeModule pour sérialiser correctement LocalDate, LocalDateTime et Instant, au lieu d’obtenir un objet JSON rempli de champs.
ObjectMapper mapper = new ObjectMapper()
.registerModule(new JavaTimeModule())
.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
String json = mapper.writeValueAsString(LocalDate.now());
System.out.println(json); // "2024-06-15"GSON comme alternative légère
GSON, proposé par Google, est plus simple que Jackson : aucune configuration n’est nécessaire pour les types de base, mais il offre moins d’annotations et de performances que Jackson à grande échelle.
Gson gson = new Gson();
String json = gson.toJson(new User("Bob", 25));
User user = gson.fromJson(json, User.class);Que sont les tampons de protocole ?
Les tampons de protocole (Protobuf) constituent le format de sérialisation binaire de Google. Vous définissez un schéma .proto, le compilez en classes Java et obtenez des messages compacts avec un versionnement intégré.
// user.proto
syntax = "proto3";
message UserProto {
string name = 1;
int32 age = 2;
}Encoder un message Protobuf
Les classes générées disposent d’une API de construction. Appelez toByteArray() pour obtenir les données binaires, puis parseFrom(bytes) pour les décoder.
UserProto user = UserProto.newBuilder()
.setName("Alice")
.setAge(30)
.build();
byte[] bytes = user.toByteArray();
UserProto restored = UserProto.parseFrom(bytes);
System.out.println(restored.getName());Compromis entre JSON et Protobuf
JSON est lisible par les humains et ne nécessite pas de schéma ; Protobuf est 3 à 10 fois plus compact et plus rapide, mais nécessite un schéma et une génération de code. Choisissez JSON pour les API REST et Protobuf pour les services internes à haut débit.
Évolution du schéma avec Protobuf
Les champs Protobuf sont numérotés et non nommés. Vous pouvez ajouter de nouveaux champs ou rendre obsolètes les anciens sans interrompre les clients existants, à condition de ne jamais réutiliser les numéros de champs.
// v2 of user.proto — backwards compatible
message UserProto {
string name = 1;
int32 age = 2;
string email = 3; // new in v2
}Migrer de la sérialisation Java
Remplacez les chemins d’écriture utilisant ObjectOutputStream par ObjectMapper.writeValue() ou par writeTo() de Protobuf. Conservez l’ancienne sérialisation uniquement pour migrer les données historiques.
Sécurité : aucun gadget de désérialisation
JSON et Protobuf n’appellent pas de constructeurs ni de méthodes arbitraires pendant la désérialisation, ce qui élimine les attaques par chaînes de gadgets qui touchent la sérialisation Java.
Vérification rapide
Quel est un avantage essentiel des tampons de protocole par rapport à JSON ?
Récapitulatif
Remplacez la sérialisation Java par le JSON de Jackson pour les API REST et la lisibilité, ou par les tampons de protocole pour les services exigeant de hautes performances. Les deux solutions sont interopérables entre les langages, permettent l’évolution du schéma et sont sécurisées par conception.
Questions Fréquemment Posées
La leçon « Solutions modernes : JSON et Protocol Buffers » est-elle gratuite ?
Oui — le texte complet de « Solutions modernes : JSON et Protocol Buffers » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Solutions modernes : JSON et Protocol Buffers » ?
Remplacez la sérialisation Java par JSON avec Jackson et Protocol Buffers pour une persistance portable et sécurisée. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Solutions modernes : JSON et Protocol Buffers » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Notions fondamentales de la sérialisation Java
- Champs transient et serialVersionUID
- Sérialisation personnalisée : writeObject et readObject
- Solutions modernes : JSON et Protocol Buffers