Wie kombinieren Sie spl_autoload_register () und is_a (), um während des automatischen Ladens Klassentyp -Beurteilung zu erhalten?

In der modernen PHP -Entwicklung sind automatische Belastungsmechanismen zu einem unverzichtbaren Teil geworden. Durch spl_autoload_register () können wir automatisch entsprechende Dateien einführen, wenn die Klasse undefiniert ist, wodurch eine große Anzahl von Anforderungen oder Einbeziehung von Aufrufen vermieden wird. In einigen Fällen möchten wir jedoch unmittelbar nach dem Laden der Klasse bestimmen, unabhängig davon, ob sie zu einem bestimmten Typ gehört (z.

In diesem Artikel wird vorgestellt, wie Sie spl_autoload_register () und is_a () kombinieren können, um die Überprüfung der Klassenart während des automatischen Ladens durchzuführen, um die Robustheit und Wartbarkeit des Codes zu verbessern.

Laden Sie die Grundlagen automatisch

SPL_AUTOLOAD_register () ermöglicht es uns, eine oder mehrere Autoloadfunktionen zu registrieren. Immer wenn eine undefinierte Klasse versucht wird, ruft PHP diese Funktionen auf, um zu versuchen, die Klassendefinition zu laden.

Der Beispielcode lautet wie folgt:

 spl_autoload_register(function ($class) {
    $path = __DIR__ . '/classes/' . $class . '.php';
    if (file_exists($path)) {
        require_once $path;
    }
});

Der obige Code sucht nach PHP -Dateien, die dem Klassennamen im Klassenverzeichnis übereinstimmen.

Bestimmen Sie den Typ nach dem Laden

In einigen Szenarien reicht nur das Laden von Klassen nicht aus. Wir möchten auch wissen, ob die Klasse eine Unterklasse einer Basisklasse ist oder eine Schnittstelle implementiert. Zu diesem Zeitpunkt können Sie IS_A () verwenden, um Urteile zu fällen:

 if (class_exists($class) && is_a($class, 'SomeInterface', true)) {
    // $class Ja SomeInterface Implementierungsklasse
}

Beachten Sie, dass der dritte Parameter hier auf true eingestellt ist, was bedeutet, dass "die Verwendung von Zeichenfolgen als Klassennamen ohne tatsächliche Instanziation erforderlich ist".

Praktisch: Kombinieren automatischer Ladung und Typ Urteilsvermögen

Im Folgenden schreiben wir einen vollständigen automatischen Loader, der automatisch feststellt, ob die Klasse nach dem Laden ein angegebener Typ ist:

 spl_autoload_register(function ($class) {
    $baseDir = __DIR__ . '/classes/';
    $file = $baseDir . $class . '.php';

    if (file_exists($file)) {
        require_once $file;

        if (!is_a($class, 'App\\Contracts\\ServiceInterface', true)) {
            throw new Exception("Art {$class} Muss erreicht werden App\\Contracts\\ServiceInterface Schnittstelle。");
        }
    } else {
        throw new Exception("无法加载Art {$class}，Die Datei existiert nicht。");
    }
});

In diesem Beispiel gehen wir davon aus, dass alle Serviceklassen die Schnittstelle von App \ Contracts \ ServiceInterface implementieren müssen. Wenn eine Klasse die Schnittstelle nicht implementiert, wird eine Ausnahme ausgelöst.

Prüfklassen und Schnittstellen

Um den obigen Code zu überprüfen, können wir die folgende Klasse und Schnittstellenstruktur erstellen:

 // Dateipfad：classes/MyService.php
namespace App\Services;

use App\Contracts\ServiceInterface;

class MyService implements ServiceInterface {
    public function handle() {
        echo "Geschäftslogik umgehen";
    }
}

// Dateipfad：classes/App/Contracts/ServiceInterface.php
namespace App\Contracts;

interface ServiceInterface {
    public function handle();
}

Verwenden Sie es dann im Hauptprogramm:

 use App\Services\MyService;

$service = new MyService();
$service->handle();

Wenn wir myService instanziieren, lädt der Autoloader die Klasse und prüft, ob er ServiceInterface implementiert. Wenn es nicht implementiert ist, wird eine Ausnahme ausgelöst.

Zusammenfassung

Durch Kombinieren von spl_autoload_register () und is_a () können wir einen robusteren automatischen Lademechanismus implementieren. Es ermöglicht nicht nur dynamisch laden Klassendateien, sondern ermöglicht es Ihnen auch, zu überprüfen, ob der Typ den Erwartungen unmittelbar nach dem Laden der Klasse erfüllt. Dieser Ansatz ist ideal für Szenarien, in denen starke Typbeschränkungen für die Entwicklung von Framework, Plug-in-Management oder große Systemarchitekturen erforderlich sind.