ReflectionObject — Klasse · PHP-Referenz

Signatur

class ReflectionObject extends ReflectionClass implements Reflector

Beschreibung

ReflectionObject ist eine spezialisierte Unterklasse von ReflectionClass und wird verwendet, um ein bereits instanziiertes Objekt zu introspektieren. Während ReflectionClass einen Klassennamen als String akzeptiert, erwartet ReflectionObject eine konkrete Objekt-Instanz. Dadurch ist es möglich, auch anonyme Klassen und dynamisch erzeugte Objekte zu untersuchen, da kein bekannter Klassenname benötigt wird.

Mit ReflectionObject lassen sich zur Laufzeit Methoden, Eigenschaften (auch private und protected), Interfaces, Traits, Konstanten und Attribute auslesen. Dies ist besonders nützlich für Frameworks, Dependency-Injection-Container, Serialisierungs-Bibliotheken und Test-Infrastrukturen.

Da ReflectionObject von ReflectionClass erbt, stehen alle Methoden der Elternklasse wie getMethods(), getProperties(), getAttributes(), implementsInterface() und viele weitere vollständig zur Verfügung.

Für rein klassenbasierte Introspektionen ohne vorhandenes Objekt empfiehlt sich direkt ReflectionClass. ReflectionObject ist die bevorzugte Wahl, wenn nur eine Instanz (z. B. aus einem Container oder einem Callback) vorliegt.

Parameter

Name	Typ	Default	Beschreibung
$object Pflicht	object		Das konkrete Objekt, über das Informationen gesammelt werden sollen. Es muss eine gültige PHP-Objekt-Instanz sein — kein Klassenname als String.

Beispiele

Grundlegende Nutzung: Methoden und Eigenschaften auslesen

<?php
class Benutzer {
    public string $name;
    protected int $alter;
    private string $passwort;

    public function __construct(string $name, int $alter, string $passwort) {
        $this->name     = $name;
        $this->alter    = $alter;
        $this->passwort = $passwort;
    }

    public function getName(): string {
        return $this->name;
    }

    private function getPasswort(): string {
        return $this->passwort;
    }
}

$benutzer = new Benutzer('Alice', 30, 'geheim123');
$ref = new ReflectionObject($benutzer);

echo "Klasse: " . $ref->getName() . PHP_EOL;

echo "\nÖffentliche Methoden:" . PHP_EOL;
foreach ($ref->getMethods(ReflectionMethod::IS_PUBLIC) as $methode) {
    echo '  - ' . $methode->getName() . '()' . PHP_EOL;
}

echo "\nAlle Eigenschaften:" . PHP_EOL;
foreach ($ref->getProperties() as $eigenschaft) {
    $eigenschaft->setAccessible(true);
    $wert = $eigenschaft->getValue($benutzer);
    echo '  - ' . $eigenschaft->getName() . ': ' . $wert . PHP_EOL;
}

Klasse: Benutzer Öffentliche Methoden: - __construct() - getName() Alle Eigenschaften: - name: Alice - alter: 30 - passwort: geheim123

Anonyme Klasse mit ReflectionObject untersuchen

<?php
$anonym = new class(42) {
    public int $wert;

    public function __construct(int $wert) {
        $this->wert = $wert;
    }

    public function verdoppeln(): int {
        return $this->wert * 2;
    }
};

$ref = new ReflectionObject($anonym);

echo "Ist anonym: " . ($ref->isAnonymous() ? 'ja' : 'nein') . PHP_EOL;
echo "Klassen-Kurzname: " . $ref->getShortName() . PHP_EOL;

foreach ($ref->getMethods(ReflectionMethod::IS_PUBLIC) as $m) {
    if (!$m->isConstructor()) {
        $ergebnis = $m->invoke($anonym);
        echo "Ergebnis von {$m->getName()}(): " . $ergebnis . PHP_EOL;
    }
}

Ist anonym: ja Klassen-Kurzname: class@anonymous Ergebnis von verdoppeln(): 84

PHP 8-Attribute per ReflectionObject auslesen

<?php
#[Attribute]
class Route {
    public function __construct(public string $path) {}
}

#[Route('/startseite')]
class StartseiteController {
    public function index(): string {
        return 'Willkommen!';
    }
}

$controller = new StartseiteController();
$ref = new ReflectionObject($controller);

foreach ($ref->getAttributes(Route::class) as $attribut) {
    $instanz = $attribut->newInstance();
    echo "Route-Pfad: " . $instanz->path . PHP_EOL;
}

Route-Pfad: /startseite

// Wichtig · Fallstricke

Sicherheitshinweis: Über setAccessible(true) (bis PHP 8.0 erforderlich, ab PHP 8.1 standardmäßig zugänglich) lassen sich private und protected Eigenschaften sowie Methoden auslesen und manipulieren. In Produktivumgebungen sollte dies nur in kontrollierten Szenarien (z. B. Test-Frameworks) eingesetzt werden, da die Kapselung des Objekts umgangen wird.

Performance: Reflection-Operationen sind im Vergleich zu direkten Zugriffen deutlich langsamer. In performance-kritischen Schleifen sollten Reflection-Ergebnisse gecacht werden.

Unterschied zu ReflectionClass: new ReflectionClass('MeineKlasse') akzeptiert einen String; new ReflectionObject($instanz) benötigt ein Objekt. Für anonyme Klassen ist ReflectionObject die einzige praktikable Option, da ihr generierter Name nicht stabil ist.

Siehe auch

ReflectionClass ReflectionMethod ReflectionProperty ReflectionAttribute Reflector