JSON vers Java

Recommandations connexes

À propos de JSON vers Java POJO et classes d'entités Java

Cas d'utilisation

• Développement Android : convertir le JSON renvoyé par l'API backend en classes d'entités Java (POJO), avec annotations Gson / Moshi / Fastjson / Jackson utilisables directement à la désérialisation
• Backend Spring Boot : transformer rapidement les exemples JSON de la documentation d'API en classes DTO / VO / Entity, en combinaison avec Lombok @Data pour réduire le volume de code
• Intégration d'API tierces : convertir la réponse JSON d'un partenaire en modèle Java correspondant et choisir la bibliothèque de sérialisation adaptée (Jackson / Fastjson / Gson) pour une intégration transparente
• Architecture microservices : unifier les modèles de données de requête/réponse des interfaces RPC, pour partager la même définition de classes Java entre plusieurs équipes
• Enseignement et formation : transformer un exemple JSON en POJO pour illustrer la modélisation orientée objet en cours de structures de données ou de Java
• Documentation d'API : intégrer des exemples d'entités Java dans la doc Swagger / OpenAPI / Knife4j
• Préparation de tests unitaires : convertir un fixture JSON en classes Java puis désérialiser avec Jackson pour des tests pilotés par les données
• Scripts de migration de données : convertir un fichier de configuration JSON en classes Java pour un accès fortement typé à la logique métier
• Mock front / back : le backend convertit d'abord le modèle JSON en Java, le front reçoit en parallèle l'interface TypeScript / POJO Java correspondante
• Revue de code : transformer directement la réponse JSON d'une API en POJO lisible, pour faciliter la discussion sur le nommage des champs en code review
• Refactoring d'anciens projets : remplacer l'accès dynamique via JSONObject par un accès fortement typé basé sur POJO
• Modélisation multi-rôles Entity / DTO : générer UserEntity (couche DB) + UserDTO (couche API) + UserVO (couche vue) à partir du même JSON, avec annotations différentes possibles
• Intégration d'API backend en snake_case : le backend renvoie des champs en snake_case, le front Java active « Convertir en camelCase » + annotations Gson/Jackson pour une intégration transparente
• DTO destinés à la persistance : cochez « Implémenter Serializable » pour les utiliser directement dans un cache Redis ou un store de session distribuée

Comment utiliser

1. Collez un objet JSON (recommandé) ou un tableau JSON dans l'éditeur de gauche, ou cliquez sur « Sample » pour charger un exemple en chinois (avec address / company / tags imbriqués)
2. Cliquez sur le bouton « Settings » de la barre d'outils (ou sur le bouton affichant le nom de classe). Dans la boîte de dialogue : ① Définissez le nom de la classe racine (par ex. User) et le package (par ex. com.example.entity) ; ② Choisissez la bibliothèque d'annotations de sérialisation (Gson / Jackson / Fastjson / Lombok / aucune) ; ③ Choisissez le style de code (toString / equals / hashCode / constructeurs / Serializable) ; ④ Choisissez la stratégie de nommage des champs (Conserver tel quel / camelCase / Tout en minuscules / UPPER_SNAKE)
3. L'outil convertit automatiquement sous 400 ms. À droite s'affichent toutes les classes Java générées (une carte par classe, avec un badge en temps réel indiquant la bibliothèque d'annotations et l'activation de Lombok) ; en cas de JSON invalide, un bouton « Réparer le JSON » apparaît
4. Vérifiez que les noms de classes, de champs et les annotations correspondent à vos attentes. Si besoin, modifiez les clés du JSON source ou rouvrez Paramètres pour ajuster les options
5. Une fois satisfait, cliquez sur le bouton « Copier » d'une classe pour la coller dans l'IDE, ou cliquez sur « Download ZIP » dans la barre d'outils pour télécharger toutes les classes en une fois (arborescence organisée selon le package)

Fonctionnalités

• 4 bibliothèques d'annotations de sérialisation : Gson (@SerializedName) / Jackson (@JsonProperty + @JsonFormat pour les dates) / Fastjson (@JSONField) / Lombok (@Data), commutables d'un clic
• Mode Lombok @Data : génère automatiquement la combinaison @Data + @Builder + @NoArgsConstructor + @AllArgsConstructor, réduisant la classe Java d'environ 50 lignes à 5 lignes
• 4 stratégies de nommage des champs : Conserver tel quel / snake_case vers camelCase (user_name → userName) / Tout en minuscules / constantes UPPER_SNAKE
• Style de code librement combinable : génération optionnelle de toString / equals / hashCode / constructeur sans argument / constructeur avec tous les arguments / implémentation de l'interface Serializable
• Inférence intelligente des types : reconnaissance automatique de String / Integer / Double / Boolean / List<Object> / objets imbriqués, sans saisie manuelle des types de champs
• Classes imbriquées générées automatiquement : les objets imbriqués sont convertis en classes Java distinctes (nommées d'après la première lettre en majuscule de la clé), les objets dans les tableaux sont nommés selon la règle « suppression du s du pluriel »
• Génériques de tableau développés automatiquement : les tableaux JSON sont convertis en types génériques Java List<T>, le type des éléments étant déduit du premier élément
• Modèle POJO complet : génération d'un fichier .java complet incluant la déclaration package + un en-tête (Copyright + horodatage automatique) + import + champs privés + getter/setter
• Téléchargement ZIP multi-fichiers : toutes les classes générées sont organisées selon le chemin du package (par ex. com/example/entity/User.java) et packagées en ZIP en un clic, avec arborescence
• Nom de package et nom de classe personnalisables : package libre (par ex. com.example.entity) et nom de classe racine (par ex. User) ; tous les noms de classes sont générés à partir du nom racine
• Contrôle de l'indentation : commutateur 2 / 4 espaces disponible à droite, pour s'aligner sur la convention de votre équipe
• Copie d'une classe unique : chaque classe Java générée dispose d'un bouton « Copier » dédié, pour collage direct dans l'IDE
• Conversion automatique + réparation d'erreurs : conversion automatique avec anti-rebond de 400 ms ; en cas de JSON invalide, un bouton « Réparer le JSON » apparaît et corrige les erreurs courantes (virgules superflues, apostrophes, etc.)
• Exemples + import de fichier : exemples en chinois intégrés (avec address / company / tags / scores imbriqués) et prise en charge du glisser-déposer ou du clic pour charger un fichier .json / .txt
• Historique local : persistance des 200 dernières entrées dans le localStorage, pour restauration rapide après rafraîchissement ou fermeture accidentelle
• Exécution locale dans le navigateur : tout le parsing JSON, la génération Java et le packaging ZIP s'exécutent en JavaScript dans votre navigateur, sans aucun envoi de données vers un serveur

Exemples de code

import com.fasterxml.jackson.databind.ObjectMapper;
import com.geekformat.pojo.User;
import com.geekformat.pojo.Address;

public class ApiClient {
    private final ObjectMapper objectMapper = new ObjectMapper();

    public User getUser(int userId) throws Exception {
        // 1) Appel API pour récupérer la chaîne JSON
        String json = httpClient.get("https://api.example.com/users/" + userId);

        // 2) Désérialisation directe vers le POJO généré
        User user = objectMapper.readValue(json, User.class);

        // 3) Accès fortement typé aux champs (vérification à la compilation)
        System.out.println("User: " + user.getName());
        if (user.getAddress() != null) {
            System.out.println("City: " + user.getAddress().getCity());
        }
        return user;
    }

    public static void main(String[] args) throws Exception {
        ApiClient client = new ApiClient();
        User user = client.getUser(123);
        System.out.println(user.getName());
    }
}

import com.geekformat.pojo.User;

public class UserService {

    public User createUser() {
        // Mode Lombok @Builder : appels chaînés, plus lisibles que les setters
        User user = User.builder()
            .id(1)
            .userName("Alice")
            .email("alice@example.com")
            .isActive(true)
            .createdAt("2026-07-08T10:00:00.000Z")
            .build();

        System.out.println(user);
        // toString() généré automatiquement par Lombok @Data :
        // User(id=1, userName=Alice, email=alice@example.com, ...)

        return user;
    }

    public boolean isValid(User user) {
        // equals() et hashCode() générés automatiquement par Lombok @Data
        return user != null && user.getId() != null;
    }
}

/*
 * Dépendance pom.xml correspondante :
 * <dependency>
 *     <groupId>org.projectlombok</groupId>
 *     <artifactId>lombok</artifactId>
 *     <version>1.18.30</version>
 *     <scope>provided</scope>
 * </dependency>
 */

# 1) Après téléchargement du ZIP (nom de fichier du type User.zip)
unzip User.zip -d src/main/java/

# 2) Vérifier l'arborescence
tree src/main/java/
# src/main/java/
# └── com/
#     └── example/
#         └── entity/
#             ├── User.java
#             ├── Address.java
#             └── Company.java

# 3) Dans IntelliJ IDEA : clic droit sur le répertoire com → "Mark Directory as" → "Sources Root"
#    Sous Eclipse : File → Import → Existing Projects into Workspace

# 4) Utilisation directe dans un projet Spring Boot
#    UserController.java
#    @PostMapping("/users")
#    public ResponseEntity<User> createUser(@RequestBody User user) {
#        userService.save(user);
#        return ResponseEntity.ok(user);
#    }

# 5) Vérification de la compilation
mvn compile
# [INFO] BUILD SUCCESS

# 6) (Optionnel) Avec Lombok, n'oubliez pas la dépendance dans pom.xml
#    <dependency>
#        <groupId>org.projectlombok</groupId>
#        <artifactId>lombok</artifactId>
#    </dependency>

FAQ

Dépannage

Glossaire

POJO

Plain Old Java Object, objet Java ordinaire. Défini par : champs privés + getter/setter publics + aucune dépendance de framework. L'outil génère des POJO standard.

JavaBean

Ancienne appellation d'un POJO dans la communauté Java : constructeur public sans argument + champs privés + getter/setter publics. Les classes générées par l'outil respectent la spécification JavaBean.

DTO (Data Transfer Object)

Objet de transfert de données, utilisé pour transporter des données entre processus (API / RPC). Les POJO générés par l'outil peuvent servir de DTO.

VO (Value Object)

Objet valeur, généralement utilisé au niveau de la vue (données renvoyées par le Controller au front). Les POJO générés par l'outil conviennent aussi.

Entity

Objet entité, correspondant à une ligne d'une table en base. Les POJO générés peuvent servir de classe de base @Entity JPA / Hibernate (après ajout manuel des annotations).

@SerializedName

Annotation de mapping de champ de la bibliothèque Gson. En mode Gson, l'outil ajoute automatiquement @SerializedName("clé d'origine") sur chaque champ pour garantir le mapping à la désérialisation.

@JsonProperty

Annotation de mapping de champ de Jackson. En mode Jackson, l'outil ajoute automatiquement @JsonProperty("clé d'origine") sur chaque champ ; les champs de date reçoivent en plus @JsonFormat pour définir le format de sérialisation.

@JSONField

Annotation de mapping de champ de la bibliothèque Fastjson d'Alibaba. En mode Fastjson, l'outil ajoute automatiquement @JSONField(name = "clé d'origine") sur chaque champ.

Lombok @Data

Annotation composite de Lombok, équivalente à @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor. En mode Lombok, l'outil ajoute cette annotation d'un clic sur la classe.

Lombok @Builder

Annotation de pattern Builder de Lombok. Lorsqu'elle est cochée, l'outil l'ajoute automatiquement et génère une méthode builder() chaînable.

Serializable

Interface marqueur de Java. Une fois implémentée, l'objet peut être sérialisé (écrit dans un fichier, transmis par le réseau, stocké dans un cache Redis). En cochant « Implémenter Serializable », l'outil ajoute implements Serializable et importe java.io.Serializable.

Classe imbriquée (Nested Class)

Classe Java distincte générée par l'outil pour un objet JSON imbriqué. Règle de nommage : la clé de l'objet imbriqué avec la première lettre en majuscule (par ex. address → Address).

Générique List

Interface du framework de collections Java. L'outil convertit automatiquement un tableau JSON en List<T>, T étant déduit du premier élément (par ex. ["a"] → List<String>).

getter / setter

Accesseurs standard d'un Java Bean. Le getter (getXxx()) renvoie la valeur du champ, le setter (setXxx(value)) la modifie. En mode Lombok, ils sont générés par @Data ; en mode traditionnel, l'outil les génère explicitement.

Déclaration package

Première ligne non commentée d'un fichier Java, déclarant l'espace de noms de la classe. L'outil la génère à partir du package choisi et organise le ZIP en répertoire com/xxx/yy.

snake_case → camelCase

Conversion de stratégie de nommage. L'outil convertit automatiquement user_name → userName, is_active → isActive, created_at → createdAt, conformément aux conventions Java.

JSZip

Bibliothèque JavaScript de packaging ZIP côté navigateur. L'outil l'utilise pour générer le ZIP directement dans le navigateur, sans traitement serveur.

Historique localStorage

Stockage clé-valeur local du navigateur (capacité d'environ 5-10 Mo). L'outil y persiste les 200 dernières entrées.

Anti-rebond (Debounce)

Technique d'optimisation frontale : fusionner des événements haute fréquence en une seule exécution finale. L'outil applique un anti-rebond de 400 ms pour éviter les ralentissements sur les gros fichiers.

tryFixJSON

Fonction de réparation JSON intégrée à l'outil : corrige automatiquement les virgules superflues en fin, les apostrophes, les clés sans guillemets, la suppression des commentaires, etc.

Table de correspondance des types JSON vers types Java

Correspondance entre les types JSON inférés automatiquement par l'outil et les types Java générés :

Comparatif des 4 bibliothèques d'annotations de sérialisation

Les 4 grandes bibliothèques d'annotations Java pour la sérialisation JSON prises en charge, à choisir selon le framework utilisé :

Comparatif des 4 stratégies de nommage des champs

Les 4 stratégies de conversion de nommage prises en charge, optimisées selon la source du JSON :

Comparatif Mode Lombok @Data vs Mode POJO traditionnel

Comparaison du nombre de lignes, de la lisibilité et des dépendances entre les deux styles :

Privacy & Security

Cet outil JSON vers Java exécute toutes ses opérations (parsing JSON, génération de classes Java, packaging ZIP) entièrement en local dans votre navigateur, en JavaScript (JSZip). Ni les données JSON saisies, ni le code Java généré ne sont envoyés à un serveur, ni enregistrés, mis en cache ou stockés dans le cloud. Vous pouvez utiliser en toute confiance des JSON sensibles (champs d'API internes, structures métier non publiées, réponses d'API confidentielles) : toutes les données disparaissent à la fermeture de la page.

Authoritative References

• MDNMDN - JSON.parse / JSON.stringify
• OracleTutoriel Oracle Java - Classes et objets
• OracleTutoriel Oracle Java - Encapsulation
• LombokDocumentation officielle Lombok - @Data
• LombokDocumentation officielle Lombok - @Builder
• JacksonDocumentation officielle Jackson - ObjectMapper
• GoogleGuide utilisateur Gson
• AlibabaFastjson GitHub
• SpringSpring Boot officiel - @RequestBody