Online JSON zu JSON Schema Generator

So funktioniert die Schema-Generierung im Hintergrund

Das Erzeugen von JSON Schema aus Beispiel-JSON umfasst mehr als nur die Zuordnung von Feldern zu Typen. Dieses Tool verwendet mehrere Schlüsseletappen für Korrektheit und Vollständigkeit:

1. Parsing: Das Tool analysiert Ihr JSON gemäß ECMA-404 und meldet detaillierte Fehler bei fehlerhaftem Input oder mehrdeutigen Konstrukten.
2. Strukturanalyse: Es erstellt eine Baumdarstellung Ihrer Daten und klassifiziert jede Eigenschaft und jedes Element nach den Kern-Typen von JSON Schema (object, array, string, number, integer, boolean, null).
3. Rekursive Traversierung: Tiefe und verschachtelte Strukturen – einschließlich Arrays von Objekten oder verschachtelten Arrays – werden rekursiv durchlaufen, um verschachtelte Schemadefinitionen zu erstellen.
4. Typableitung und Zusammenführung: Für jede Eigenschaft oder Array-Element werden Typen abgeleitet. Wenn Eigenschaften oder Items gemischte Typen haben, wird der 'type' als Array (Union-Typ) gemäß JSON Schema Spezifikation angegeben.
5. Erkennung von Pflicht- und optionalen Feldern: Durch Analyse aller Objekte auf jeder Ebene unterscheidet das Tool zwischen immer vorhandenen (erforderlichen) und manchmal fehlenden (optionalen) Schlüsseln.
6. Wert-Einschränkungen: Wo möglich leitet das Tool Enums (erlaubte Werte), Min/Max für Zahlen, MinLength/MaxLength für Strings und Format-Hinweise (wie 'email', 'uri' oder 'date-time') ab.
7. Sonderfallbehandlung: Besondere Aufmerksamkeit gilt leeren Arrays, Nullwerten und spärlichen Strukturen – für gültige Schemata, die reale Variabilität abbilden.
8. Schema-Synthese: Das finale Schema wird als standardskonformes Draft-07 Dokument ausgegeben – einsatzbereit für Tools wie Ajv, OpenAPI oder Code-Generatoren.

Warum JSON Schema generieren? Praktische Anwendungsfälle

• Automatisierte Validierung: Nutzen Sie generierte Schemas zur Durchsetzung von Datenverträgen und Validierung eingehender Payloads in APIs, Microservices oder CLIs.
• API-Dokumentation: Automatisch Dokumentationen und interaktive Explorer (Swagger, Postman) mit präzisen Datendefinitionen erzeugen.
• Code-Generierung: Erstellen Sie typsichere Modelle oder Validatoren in TypeScript, Python, Java und anderen Sprachen mit Ihrem Schema als einziger Wahrheit.
• Testdatengenerierung: Tools wie JSON Schema Faker oder Mockaroo nutzen Schemata, um realistische Mock-Daten für QA und Lasttests zu erzeugen.
• Refactoring & Migration: Validieren Sie Legacy- oder sich ändernde Datenstrukturen, um Kompatibilität beim Backend-Wandel sicherzustellen.

Technische Merkmale

• Draft-07-Kompatibilität für maximale Interoperabilität mit wichtigen Validatoren und API-Design-Plattformen.
• Rekursive Analyse beliebiger Verschachtelungstiefe – Arrays in Arrays, Objekte in Arrays usw.
• Präzise Union-Typ-Ableitung ('type' Array) für Felder oder Elemente mit variierenden Typen über Beispiele hinweg.
• Automatische Erkennung von Enums, Länge, Muster, Format, Min/Max und anderen gängigen Einschränkungen.
• Explizite Unterstützung für Nullwerte, leere Arrays/Objekte und partielle Datensätze.
• Schema-Generierung läuft komplett im Browser. Ihr Eingabe-JSON verlässt niemals Ihr Gerät.

Technisches Beispiel: Von Beispiel-JSON zum Draft-07 Schema

{
  "transaction": {
    "id": "txn_abc123",
    "amount": 99.95,
    "currency": "USD",
    "status": "completed",
    "meta": {
      "ip": "203.0.113.1",
      "tags": ["recurring", null]
    }
  },
  "refunded": false,
  "notes": null
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "transaction": {
      "type": "object",
      "properties": {
        "id": { "type": "string" },
        "amount": { "type": "number" },
        "currency": { "type": "string", "minLength": 3, "maxLength": 3 },
        "status": { "type": "string", "enum": ["completed"] },
        "meta": {
          "type": "object",
          "properties": {
            "ip": { "type": "string", "format": "ipv4" },
            "tags": {
              "type": "array",
              "items": { "type": ["string", "null"] }
            }
          },
          "required": ["ip", "tags"]
        }
      },
      "required": ["id", "amount", "currency", "status", "meta"]
    },
    "refunded": { "type": "boolean" },
    "notes": { "type": ["null"] }
  },
  "required": ["transaction", "refunded", "notes"]
}

So nutzen Sie dieses JSON zu JSON Schema Tool

1. Fügen Sie Ihr Beispiel-JSON in den untenstehenden Editor ein oder tippen Sie es ein. Das Tool akzeptiert beliebiges gültiges JSON, von einfachen Objekten bis zu tief verschachtelten Strukturen.
2. Klicken Sie auf 'JSON Schema generieren', um das erzeugte JSON Schema zu erstellen und anzuzeigen.
3. Kopieren, bearbeiten oder laden Sie das Schema herunter. Integrieren Sie es direkt in Ihre API-Definitionen, Validierungslogik oder Dokumentation.

Codebeispiele für die Generierung von JSON-Schemas

Erfahren Sie, wie Sie aus JSON in verschiedenen Programmiersprachen ein JSON-Schema erstellen.

const generateSchema = require('jsonschema-generator');
const data = {
  name: "Alice",
  age: 30,
  isActive: true,
  tags: ["user", "admin"]
};
const schema = generateSchema(data);
console.log(JSON.stringify(schema, null, 2));

const GenerateSchema = require('generate-schema');
const data = { name: "Alice", age: 30, tags: ["admin", "user"] };
const schema = GenerateSchema.json('User', data);
console.log(JSON.stringify(schema, null, 2));

from genson import SchemaBuilder
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
builder = SchemaBuilder()
builder.add_object(sample)
print(builder.to_json(indent=2))

from jsonschema_generate import generate_schema
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
schema = generate_schema(sample)
print(schema)

package main
import (
  "encoding/json"
  "fmt"
  "github.com/invopop/jsonschema"
)
type User struct {
  Name string   `json:"name"
  Age  int      `json:"age"
  Tags []string `json:"tags"
}
func main() {
  schema := jsonschema.Reflect(&User{})
  out, _ := json.MarshalIndent(schema, "", "  ")
  fmt.Println(string(out))
}

# Generate Java POJOs *from* a JSON Schema, not the reverse.
# For schema generation from Java, see tools like jackson-module-jsonSchema.
# See: https://github.com/FasterXML/jackson-module-jsonSchema

using NJsonSchema;
using Newtonsoft.Json.Linq;
var sample = JObject.Parse("{\"name\":\"Alice\",\"age\":30, \"tags\":[\"user\"]}");
var schema = await JsonSchema.FromSampleJsonAsync(sample.ToString());
Console.WriteLine(schema.ToJson());

require 'vendor/autoload.php';
use Swaggest\JsonSchema\Structure\ClassStructure;
$sample = ["name" => "Alice", "age" => 30, "tags" => ["user"]];
$schema = ClassStructure::exportSchema($sample);
echo json_encode($schema, JSON_PRETTY_PRINT);

require 'json_schemer'
sample = { "name" => "Alice", "age" => 30, "tags" => ["admin", "user"] }
schema = JSONSchemer.schema(sample)
puts schema.to_json

echo '{"name":"Alice","age":30,"tags":["user","admin"]}' | genson | jq .

use schemars::JsonSchema;
use serde::Serialize;
#[derive(Serialize, JsonSchema)]
struct User {
  name: String,
  age: u32,
  tags: Vec<String>,
}
fn main() {
  let schema = schemars::schema_for!(User);
  println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

import json.schema._
case class User(name: String, age: Int, tags: List[String])
val schema = Json.schema[User]
println(schema.asSpray.prettyPrint)

# Generate schema from a TypeScript interface:
typescript-json-schema tsconfig.json User --out schema.json
# See https://github.com/YousefED/typescript-json-schema

// Dart does not have an automatic JSON Schema generator yet.
// Manually define schema as a Dart Map or use online tools.