JSON-Schema-Generator

Der JSON-Schema-Generator liest ein Beispiel-JSON-Dokument und erzeugt ein Draft-07-Schema, das seine Struktur beschreibt: Typen, verschachtelte Objekte und Arrays. Er ist für API-Entwickler gedacht, die einen Validierungs-Ausgangspunkt möchten, ohne jede Eigenschaft von Hand zu schreiben, und für Teams, die eine JSON-Payload schnell dokumentieren müssen.

Anleitung

Fügen Sie ein Beispiel in das Eingabefeld ein oder drücken Sie die Beispiel-Schaltfläche, um ein Demo-Objekt zu laden. Drücken Sie auf Generieren. Das Tool parst das JSON, durchläuft die Struktur und schreibt ein formatiertes Schema in das Ausgabefeld. Prüfen Sie das Ergebnis und kopieren Sie es in Ihren Validator, Ihre Vertragstests oder Ihre Dokumentation. Ungültiges JSON wird als Fehler gemeldet, statt eine Teilausgabe zu erzeugen.

Was das generierte Schema enthält

Die Ausgabe beginnt immer mit "$schema": "http://json-schema.org/draft-07/schema#". Darüber hinaus erzeugt sie:

• type für jeden Knoten: object, array, string, integer, number, boolean oder null.
• properties für jeden Schlüssel jedes Objekts, rekursiv.
• items für Arrays, abgeleitet aus dem ersten Element.

Sie erzeugt kein required, enum, format, pattern, keine numerischen Grenzen und kein oneOf. Diese Schlüsselwörter existieren in der zugrunde liegenden Bibliothek, aber der von der Seite genutzte Generierungspfad erzeugt nur type, properties und items. Behandeln Sie das Ergebnis als strukturelles Skelett und ergänzen Sie Ihre echten Einschränkungen anschließend.

Praxisbeispiel

Eingabe:

{
  "name": "John Doe",
  "age": 30,
  "isActive": true,
  "tags": ["developer", "designer"],
  "address": { "city": "San Francisco", "zipCode": "94105" }
}

Ausgabe (gekürzt):

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" },
    "isActive": { "type": "boolean" },
    "tags": { "type": "array", "items": { "type": "string" } },
    "address": {
      "type": "object",
      "properties": {
        "city": { "type": "string" },
        "zipCode": { "type": "string" }
      }
    }
  }
}

Weil kein required-Array vorhanden ist, akzeptiert ein Validator {} als gültig gegen dieses Schema. Das ist meist nicht gewünscht, ergänzen Sie also "required": ["name", "address"] und etwaige Formatregeln von Hand.

Draft-07 und Kompatibilität

Draft-07 ist ein weit verbreiteter Dialekt. Ajv verarbeitet ihn in JavaScript, das jsonschema-Paket in Python, und die meisten Schema-Werkzeuge akzeptieren ihn weiterhin. Neuere Spezifikationen wie 2020-12 ändern einige Schlüsselwörter, und OpenAPI 3.1 baut auf 2020-12 auf, ein Draft-07-Schema kann also kleinerer Anpassungen bedürfen, bevor es sauber in eine OpenAPI-3.1-Datei passt. Die $schema-Zeile sagt Konsumenten, welchen Dialekt sie verwenden sollen, lassen Sie sie also stehen. Draft-07 erlaubt außerdem boolesche Schemata und bedingte Schlüsselwörter wie if, then und else; der Generator erzeugt sie nicht, aber Sie können sie von Hand ergänzen.

Grenzen der Inferenz, die Sie kennen sollten

Nur das erste Array-Element wird untersucht. Ein Array wie [{"a":1},{"b":2}] wird als items eines Objekts mit der Eigenschaft a beschrieben; die zweite Form bleibt unsichtbar. Leere Arrays erhalten leere items und schränken nichts ein. Jede Zeichenkette ist reines string ohne format, E-Mails, Daten und UUIDs sehen also identisch aus. Nulls bleiben als type: null erhalten, was in strengen Validatoren nur null erlaubt; ist ein Feld manchmal null und manchmal eine Zeichenkette, ist das Schema für einen dieser Fälle falsch. Doppelte Schlüssel in der Quelle werden von JSON.parse aufgelöst, es überlebt also nur das letzte Vorkommen. Und weil die Inferenz auf einem Beispiel basiert, wird ein Feld, das heute zufällig eine Ganzzahl ist, auf integer festgelegt, selbst wenn die API später Dezimalwerte liefert. Die Schlüsselreihenfolge von Objekten entspricht der Stichprobe, doch die Eigenschaftsreihenfolge ist für die Validierung unerheblich, und die Eingabe muss striktes JSON sein, Kommentare und abschließende Kommas werden also abgelehnt.

Das Skelett zu echter Validierung erweitern

Das generierte Schema parst, akzeptiert für sich genommen aber zu viel. Der übliche nächste Schritt ist, required-Felder, Formate und Grenzen zu ergänzen.

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["name", "address"],
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0, "maximum": 150 },
    "email": { "type": "string", "format": "email" },
    "isActive": { "type": "boolean" }
  }
}

Ergänzen Sie required für die Felder, die immer vorhanden sein müssen. Ergänzen Sie format für Zeichenketten, die E-Mails, Daten oder URIs darstellen, und bedenken Sie, dass manche Validatoren format ignorieren, solange die Formatprüfung nicht ausdrücklich aktiviert ist. Ergänzen Sie minimum, maximum, minLength und pattern für die Regeln, die eine einzelne Stichprobe nicht offenlegen kann.

Wenn Sie mehrere Stichproben haben, führen Sie sie von Hand zusammen. Die Bibliothek hinter der Seite kann Schlüssel erkennen, die in jeder Stichprobe vorkommen, aus einer kleinen Menge wiederholter Werte ein enum bilden und unterschiedliche Formen mit oneOf kombinieren, doch die Seite speist sie mit einem einzigen Dokument. Diese Verfeinerungen bleiben Ihnen überlassen. Um tatsächlich zu validieren, speichern Sie die Datei als schema.json und kompilieren Sie sie mit Ajv in JavaScript oder übergeben Sie sie in Python an jsonschema.validate(instance, schema).

Häufige Fehler

Zu erwarten, dass der Generator Pflichtfelder markiert. Ein minimales Beispiel einzuspeisen und anzunehmen, jede Eigenschaft, die die API zurückgeben kann, werde erscheinen. Sich darauf zu verlassen, dass er enum-artige Werte, Zeichenkettenformate oder numerische Bereiche erkennt. Ein Array von Datensätzen einzufügen und anzunehmen, alle Datensätze seien analysiert worden. Und die rohe Ausgabe als Produktionsvalidierung auszuliefern, ohne die Einschränkungen zu ergänzen, die die Stichprobe nicht ausdrücken kann. Noch einer: eine JSON-Zeichenkette einfügen, die selbst JSON enthält, und erwarten, dass das innere Dokument beschrieben wird; es wird nur der Typ der obersten Zeichenkette abgeleitet.

Verwandte Tools

• JSON-Formatierer
• JSON zu TypeScript
• JSON-Diff
• JSON-Visualizer
• Testdaten-Generator