JSON zu PHP

Ähnliche Tools

Über JSON zu PHP-Klasse und PHP-Entitätsklassenmodellierung

Anwendungsfälle

• Laravel-Backend-Entwicklung: Schnelles Konvertieren von Beispiel-JSON aus API-Schnittstellendokumentation in Eloquent Model / API Resource-Klassen, direkte Serialisierung von Responses mit integrierten Jsonable / Arrayable-Schnittstellen von Laravel
• Symfony Serializer-Integration: Konvertieren von von Drittanbieter-APIs zurückgegebenem JSON in PHP-Klassen im ArrayObject-Stil, tiefes Objekt-Mapping und Datenvalidierung mit Symfony Serializer
• WordPress REST API: Konvertieren von von benutzerdefinierten Endpunkten zurückgegebener JSON-Struktur in PHP-Klassen im stdClass-Stil, direkte Ausgabe mit wp_send_json(), konform zum Standardverhalten von wp_json_encode()
• PHP 8.1+ readonly DTO: Konvertieren von JSON in final readonly class für Data Transfer Objects (DTO), nach Konstruktion unveränderlich, verhindert, dass Geschäftslogik versehentlich Antwortdaten ändert
• Composer-Paket-Entwicklung: Konvertieren von JSON Schema in PHP-Klassen dann Veröffentlichung auf Packagist als SDK-Modellschicht, damit andere Composer-Projekte es require und wiederverwenden
• Unit-Test-Fixtures: Konvertieren von JSON-Fixtures in PHP-Klassen dann Verwendung mit json_decode + Deserialisierung für datenbasierte Tests, Assertion strukturierter Felder
• Datenmigrationsskripte: Konvertieren von JSON-Konfigurationsdateien in PHP-Klassen dann Verwendung für stark typisierten Zugriff in Geschäftslogik, einfacher IDE-Autovervollständigung und Typprüfung als Array-Zugriff
• Frontend-Mock-Integration: Backend konvertiert zuerst JSON-Modelle in PHP-Klassen, Frontend erhält gleichzeitig entsprechende TypeScript-Schnittstelle / PHP-Klasse, hält Typen an beiden Enden konsistent
• Code Review: Direktes Konvertieren von API-Response-JSON in lesbare PHP-Klassen, erleichtert Diskussion von Feldbenennung, Eigenschaftssichtbarkeit während Code Review
• Legacy-Projekt-Refaktorisierung: Refaktorisieren von dynamischem Zugriffscode basierend auf assoziativem Array in stark typisierten Zugriff basierend auf PHP-Klasse, statische Analyse mit PHPStan / Psalm durchführen
• PHPUnit DataProvider: Konvertieren von JSON-Testdaten in PHP-Klassen dann Injection in Testfall via DataProvider, IDE schlägt automatisch Eigenschaftsfelder vor
• Backend-API-Integration snake_case: Backend-API gibt snake_case-Felder zurück, Frontend-PHP-System aktiviert 'in camelCase konvertieren' + ArrayObject-Stil für nahtlose Integration
• Statische Analyse PHPStan: Generierte Klassen haben natürlich Typdeklarationen, mit phpstan analyse --level=8 Typfehler in CI abfangen
• Lehre und Ausbildung: In PHP-Lehrszenarien Konvertieren von Beispiel-JSON in PHP-Klassen zur Demonstration objektorientierter Modellierung, Typsystem, Schnittstellenimplementierung
• API-Gateway-Schicht: Konvertieren von von vorgelagerten Microservices zurückgegebenem JSON in PHP-Klassen zur Aggregation in Gateway-Schicht, nachgelagerte PHP-Dienste konsumieren stark typisiert über Klasseneigenschaften
• Message Queue-Konsum: Konvertieren von von RabbitMQ / Kafka konsumierten JSON-Nachrichtenkörpern in PHP-Klassen dann Speicherung oder Weiterleitung, strikte Analyse mit JSON_THROW_ON_ERROR
• E-Commerce SKU/SPU-Modellierung: Konvertieren von Produkt-JSON-Struktur (Multi-Spezifikation / Multi-Bild / Multi-Attribut) in PHP-Klassen, mit ArrayObject-Stil N+1-Abfrageoptimierung in Laravel durchführen
• WebHook-Callback-Signaturprüfung: Konvertieren von JSON-Signaturprüfstruktur von Zahlungsgateways, Logistik-Callbacks in PHP-Klassen, Signaturprüfung mit hash_hmac()
• OpenAPI-Toolchain: Konvertieren von OpenAPI 3.x-JSON-Schema in PHP-Klassen, Integration in PHP-Client-Generierungs-Workflow von Swagger Codegen / Apifox
• Daten-ETL-Pipeline: Konvertieren von JSON aus vorgelagerten Datenquellen (MySQL-JSON-Feld / MongoDB / Elasticsearch) in PHP-Klassen dann Datenbereinigung und -speicherung

Anleitung

1. Fügen Sie JSON-Objekt (empfohlen) oder Array in linken Editor ein, oder klicken Sie auf 'Sample', um chinesisches Beispiel zu laden (mit verschachtelten address / company / tags)
2. Klicken Sie auf 'Settings'-Schaltfläche in der Toolbar, wählen Sie im Dialog: ① Root-Klassennamen festlegen (z. B. User) und Namespace (z. B. App\Models); ② Codestil auswählen (ArrayObject / stdClass / readonly class); ③ Code-Funktionen auswählen (typed properties / Laravel-Integration / Symfony Serializer); ④ Feldnamensstrategie auswählen (Original beibehalten / camelCase / alles kleinbuchstaben / UPPER_SNAKE)
3. Tool konvertiert automatisch innerhalb von 400ms, rechte Seite zeigt alle generierten PHP-Klassen an (jede Klasse separate Karte, Titelleiste zeigt aktuelles Stil-Badge in Echtzeit); bei JSON-Formatfehlern wird Schaltfläche 'JSON reparieren' angezeigt
4. Überprüfen Sie, ob generierte Klassennamen, Eigenschaftsnamen und Schnittstellen den Erwartungen entsprechen; falls Anpassung erforderlich, können Sie Schlüsselnamen des Quell-JSON ändern oder Settings erneut öffnen, um Optionen zu ändern
5. Wenn zufrieden, können Sie auf 'Kopieren'-Schaltfläche einzelner Klasse klicken, um in IDE einzufügen, oder auf 'Download ZIP' in der Toolbar klicken, um alle Klassen mit einem Klick herunterzuladen (Verzeichnisstruktur nach Namespace-Pfad organisiert)

Funktionen

• Zwei frei umschaltbare Codestile: ArrayObject (erweitert \ArrayObject, unterstützt Array-Zugriff $obj['key']) / stdClass (erweitert \stdClass, unterstützt Objektzugriff $obj->key), kompatibel mit verschiedenen Szenarien wie Laravel-Serialisierung, WordPress REST, Symfony Serializer
• Vollständiges PHP-Template: generiert automatisch Namespace-Deklaration + use-Anweisungen + Klassenkopfkommentar (Copyright + Generierungszeitstempel) + Klassendefinition + öffentliche typisierte Eigenschaften (PHP 7.4+), direkt in Composer-Projekt per require einbindbar ohne manuelle Boilerplate-Ergänzung
• Automatisch implementierte JsonSerializable-Schnittstelle: Jede generierte Klasse erstellt automatisch public function jsonSerialize(): mixed { return [...] }, direkt mit json_encode() JSON serialisieren, null zusätzlicher Boilerplate-Code
• Optional PHP 8.1+ readonly class: Bei Aktivierung fügt generierte Klasse final readonly class hinzu, alle Eigenschaften sind readonly, nach Konstruktion unveränderlich, geeignet für Szenarien mit unveränderlichen API-Response-DTOs
• Intelligente Typinferenz: string → string, integer → int, float → float, bool → bool, array → array, verschachtelte Objekte → unabhängige Klasse, null → ?type (nullable-Eigenschaft), keine manuelle Feldtypspezifikation erforderlich
• Verschachtelte Klassen automatisch aufgeteilt: Verschachtelte Objekte generieren unabhängige PHP-Klassen mit erstem Buchstaben des Feldnamens großgeschrieben (z. B. address → Address), Objekte in Arrays nach Regel 's-Endung entfernen' benannt (z. B. users → User), alle verschachtelten Klassen implementieren ebenfalls JsonSerializable
• 4 Feldnamensstrategien: Original beibehalten / snake_case zu camelCase (user_name → userName) / alles kleinbuchstaben / UPPER_SNAKE-Konstantenstil, konform zu verschiedenen Codestandards PSR-1 / Laravel / Symfony
• Ein-Klick-Laravel-Integration: Bei Aktivierung automatisch Jsonable-, Arrayable-Schnittstellen implementiert, toArray() / toJson()-Methoden hinzugefügt, direkt als Eloquent API Resource verwendbar, mit Composer-Autoload
• Einzelklasse kopieren + Multi-Datei-ZIP-Download: Jede PHP-Klasse hat separate 'Kopieren'-Schaltfläche, kann mit einem Klick ZIP-Paket herunterladen, organisiert nach Namespace-Verzeichnisstruktur (z. B. App/Models/User.php), entpacken und verwenden
• Lokale Browserausführung + Verlauf: JSON-Analyse, PHP-Klassen-Generierung, ZIP-Paketerstellung über JavaScript (quicktype-core + JSZip) im Browser, Daten nicht an Server hochgeladen; integrierter localStorage-Verlauf für 200 aktuelle Einträge

Codebeispiele

<?php

require_once 'vendor/autoload.php';

use App\Models\User;

// Simulieren einer von API empfangenen JSON-Zeichenkette
$jsonString = '{"id":1,"name":"Alice","email":"a****@***********","isActive":true}';

// 1) Deserialisieren in von diesem Tool generierte Klasse
$userData = json_decode($jsonString, true);
$user = new User(
    $userData['id'],
    $userData['name'],
    $userData['email'],
    $userData['isActive']
);

// 2) Stark typisierter Feldzugriff (IDE-Autovervollständigung + PHPStan-statische Prüfung)
echo $user->name;          // Alice
echo $user->email;         // a****@***********
echo $user->isActive ? 'Aktiv' : 'Inaktiv'; // Aktiv

// 3) json_encode() ruft automatisch jsonSerialize() auf, kein zusätzlicher Code erforderlich
echo json_encode($user, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
/*
{
    "id": 1,
    "name": "Alice",
    "email": "a****@***********",
    "isActive": true
}
*/

<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * GET /api/users/{id}
     */
    public function show(int $id): JsonResponse
    {
        // 1) 从数据库或外部 API 获取数据
        $userData = $this->fetchUserFromApi($id);

        // 2) 用本工具生成的 User 类包装
        $user = new User(
            $userData['id'],
            $userData['name'],
            $userData['email'],
            $userData['isActive']
        );

        // 3) 直接 return response()->json($user)
        //    Laravel 会自动调用 jsonSerialize()
        return response()->json($user);
    }

    /**
     * POST /api/users
     */
    public function store(Request $request): JsonResponse
    {
        // 4) 反向用法：把请求 JSON 反序列化为 User 类
        $user = User::fromArray($request->all());

        // 5) 用 toArray() 获取数组形式
        $payload = $user->toArray();

        // 6) 执行业务逻辑（如入库 / 调用第三方 API）
        $this->userService->create($payload);

        return response()->json([
            'message' => 'User created',
            'data' => $user,
        ], 201);
    }
}

/*
 * 对应 composer.json 依赖：
 * "require": {
 *     "php": "^8.1",
 *     "laravel/framework": "^11.0"
 * }
 */

<?php

namespace App\Service;

use App\Models\User;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;

class UserSerializer
{
    private SerializerInterface $serializer;

    public function __construct(SerializerInterface $serializer)
    {
        // 使用 PropertyNormalizer 处理 public 属性
        $this->serializer = $serializer;
    }

    /**
     * 将 User 对象序列化为 JSON 字符串
     */
    public function toJson(User $user): string
    {
        return $this->serializer->serialize($user, 'json');
    }

    /**
     * 将 JSON 字符串反序列化为 User 对象
     */
    public function fromJson(string $json): User
    {
        return $this->serializer->deserialize($json, User::class, 'json');
    }

    /**
     * 批量反序列化（如从 MongoDB 导出的 JSON 数组）
     */
    public function fromJsonArray(string $jsonArray): array
    {
        $users = [];
        $data = json_decode($jsonArray, true);

        foreach ($data as $item) {
            $users[] = User::fromArray($item);
        }

        return $users;
    }
}

// 使用示例
$serializer = new UserSerializer($serializerService);

$json = '{"id":1,"name":"Alice","address":{"city":"Beijing","zip":"100000"},"tags":["php","symfony"]}';

// 反序列化为本工具生成的 User 对象
$user = $serializer->fromJson($json);
echo $user->name;                  // Alice
echo $user->address->city;         // Beijing (强类型访问)
print_r($user->tags);              // ['php', 'symfony']

// 序列化回 JSON
$jsonOutput = $serializer->toJson($user);

Best Practices

Häufig gestellte Fragen

Fehlerbehebung

Glossar

namespace

In PHP 5.3+ eingeführter Namensraumm Mechanismus zur Vermeidung von Klassennamenskonflikten. Dieses Tool generiert automatisch nach vom Benutzer konfiguriertem Namespace und organisiert im ZIP nach Verzeichnis App/Models/.

class

Vorlage zur Definition von Objekten in PHP. Dieses Tool generiert Standard-PHP-class, direkt über new User(...) instanziierbar.

ArrayObject

Klasse in PHPs Standard-SPL-Bibliothek, die Schnittstellen wie ArrayAccess implementiert. Von diesem Tool im ArrayObject-Stil generierte Klassen erben von \ArrayObject und unterstützen doppelten Array- und Objektzugriffsstil.

stdClass

PHPs eingebaute generische Objektklasse; json_decode($json, false) gibt standardmäßig diesen Typ zurück. Von diesem Tool im stdClass-Stil generierte Klassen erben von \stdClass und unterstützen nur Objektzugriffsstil.

typed properties

In PHP 7.4+ eingeführte Eigenschaftstypdeklarationen (z. B. public int $id). Von diesem Tool generierte Eigenschaften haben standardmäßig Typdeklarationen; IDE und statische Analysetools können direkt Typprüfung durchführen.

readonly class

In PHP 8.1+ eingeführte schreibgeschützte Klasse; alle Eigenschaften in der Klasse sind automatisch readonly, nach Konstruktion nicht änderbar. Dieses Tool generiert im readonly-Stil final readonly class, geeignet für unveränderliche DTO-Szenarien.

JsonSerializable

In PHP 5.4+ eingeführte Schnittstelle; Objekte, die diese Schnittstelle implementieren, rufen bei json_encode() automatisch Methode jsonSerialize() auf. Alle Klassen dieses Tools implementieren automatisch diese Schnittstelle.

Jsonable (Laravel)

Contract-Schnittstelle des Laravel-Frameworks; nach Implementierung kann Objekt toJson() aufrufen, um JSON auszugeben. Laravel-Integrationsstil dieses Tools implementiert automatisch diese Schnittstelle.

Arrayable (Laravel)

Contract-Schnittstelle des Laravel-Frameworks; nach Implementierung kann Objekt toArray() aufrufen, um Array auszugeben. Laravel-Integrationsstil dieses Tools implementiert automatisch diese Schnittstelle.

Composer

Offizielles Dependency-Management-Tool von PHP. Bei Verwendung von von diesem Tool generiertem Code muss PSR-4-Autoload in composer.json konfiguriert werden (z. B. App\\: src/).

PSR-4

Von PHP-FIG spezifizierte Autoload-Norm, die Klassendateien über Namespace-zu-Verzeichnis-Mapping lädt. Von diesem Tool generiertes ZIP-Paket ist nach Namespace-Pfad organisiert, konform zur PSR-4-Norm.

Symfony Serializer

Serialisierungsframework der Symfony-Komponente. Von diesem Tool im ArrayObject-Stil generierte Klassen können mit PropertyNormalizer von Symfony Serializer für tiefe Serialisierung und Deserialisierung zusammenarbeiten.

Eloquent API Resource

API-Ressourcenklasse von Laravel Eloquent, verwendet zum Formatieren von API-Responses. Von diesem Tool im Laravel-Integrationsstil generierte Klassen können direkt als API Resource-Basisklassen verwendet werden.

composer.json

Konfigurationsdatei des Composer-Projekts. Nach Platzierung von von diesem Tool generiertem Code im src-Verzeichnis muss autoload-Abschnitt in composer.json konfiguriert und composer dump-autoload ausgeführt werden.

json_encode / json_decode

PHPs eingebaute JSON-Serialisierungs- und Deserialisierungsfunktionen. Nachdem von diesem Tool generierte Klassen JsonSerializable implementieren, ruft json_encode() automatisch Methode jsonSerialize() auf.

PHPUnit DataProvider

Datenanbietermechanismus des PHP-Testframeworks PHPUnit. Von diesem Tool generierte PHP-Klassen können als DataProvider in Testfälle injiziert werden, verbessern Effizienz beim Schreiben von Tests mit IDE-Autovervollständigung.

PHPStan

Statisches Analysetool für PHP, kann Typprüfung und Fehlererkennung auf Code durchführen. Von diesem Tool generierte Klassen können mit typed properties Eigenschaftstypen vollständig von PHPStan im Modus --level=8 inferiert werden.

Psalm

Ein weiteres statisches Analysetool für PHP, Open-Source von Vimeo. Von diesem Tool generierte Klassen können mit Psalms PropertyTypeProvider starke Typvalidierung durchführen.

Doctrine

ORM- und DBAL-Toolset im PHP-Ökosystem. Von diesem Tool generierte PHP-Klassen können als Skelett für Doctrine Entity dienen, dann manuell Annotationen wie #[ORM\Column] hinzugefügt werden.

php -l

Syntaxprüfungsanweisung in PHP-Befehlszeile. Von diesem Tool generierte Klassen können vor require im Projekt zuerst php -l User.php zur Syntaxvalidierung ausführen.

Composer dump-autoload

Befehl für Composer, um Autoload-Index neu zu generieren. Nach Platzierung von von diesem Tool generierten Klassen im src-Verzeichnis muss composer dump-autoload ausgeführt werden, um von PSR-4-Autoload erkannt zu werden.

JSON_THROW_ON_ERROR

Flag für Fehlerbehandlung von json_decode() in PHP 7.3+; bei Aktivierung wirft fehlgeschlagene JSON-Analyse JsonException. Laravel-Beispiel dieses Tools verwendet strikte Analyse.

Hash (PHP)

PHPs eingebaute Hash-Funktion, häufig verwendet für WebHook-Signaturprüfung. Von diesem Tool generierte WebHook-Callback-Klassen arbeiten mit hash_hmac() zur Signaturprüfung.

Referenztabelle JSON-Typ zu PHP-Typ-Mapping

JSON-Datentypen automatisch von Tool erkannt und Referenz des entsprechenden PHP-Typs:

Vergleichstabelle 4 PHP-Codestile

4 von Tool unterstützte PHP-Klassen-Codestile; wählen Sie nach Projektanforderungen:

Privacy & Security

Alle JSON-Analyse-, PHP-Klassen-Generierungs-, ZIP-Paketerstellungsvorgänge dieses JSON zu PHP-Tools erfolgen vollständig lokal in Ihrem Browser über JavaScript (quicktype-core + JSZip); eingegebene JSON-Daten und generierter PHP-Code werden an keinen Server hochgeladen, noch in der Cloud gespeichert, zwischengespeichert oder gespeichert. Sensibles JSON mit internen Schnittstellenfeldern, nicht veröffentlichten Geschäftsstrukturen, nicht öffentlichen API-Antworten kann sicher verwendet werden; alle Daten werden bei Seitenschließung gelöscht. Dieses Tool verwendet keine Cookies zur Benutzerverfolgung, sammelt keine E-Mail- oder Kontoinformationen, integriert keine Drittanbieter-Statistikskripte; alle Berechnungen erfolgen im Browserprozess des aktuellen Geräts. Selbst in Offline-Umgebung (z. B. getrennt oder isoliertes Intranet) funktioniert es normal, solange Seitenressourcen einmal geladen wurden.

Authoritative References

• PHP.netPHP Offizielle Dokumentation - Klassen und Objekte
• PHP.netPHP Offizielle Dokumentation - JsonSerializable-Schnittstelle
• PHP.netPHP Offizielle Dokumentation - Readonly-Modifikator (PHP 8.1+)
• PHP.netPHP Offizielle Dokumentation - Typisierte Eigenschaften (PHP 7.4+)
• PHP-FIGPSR-4 Autoload-Standard
• LaravelLaravel Offizielle Dokumentation - Eloquent: API Resources
• SymfonySymfony Serializer-Komponente Dokumentation
• ComposerComposer Offizielle Dokumentation - PSR-4 Autoload