[Modernes PHP] Kapitel 2 Neue Funktionen 2 Schnittstellenbasierte Programmierung

Schnittstellenbasierte Programmierung

Als PHP-Programmierer hat das Erlernen des schnittstellenbasierten Programmierens mein Leben verändert und meine Fähigkeit, PHP-Komponenten von Drittanbietern zu integrieren, erheblich verbessert . um meine Projektfähigkeiten zu verbessern. Schnittstellen sind kein neues Feature, aber es handelt sich um wichtige Features, die Sie bei Ihrer täglichen Arbeit verstehen und nutzen müssen.

Was genau ist also die Schnittstelle von PHP? Eine Schnittstelle ist ein Vertrag zwischen zwei PHP-Objekten. Wenn ein Objekt ein anderes Objekt aufruft, muss es nicht wissen, was die andere Partei ist, sondern nur wissen, was die andere Partei tun kann. Schnittstellen können die Kopplung der Abhängigkeiten unseres Codes reduzieren, sodass unser Code jeden Code von Drittanbietern aufrufen kann, der die gewünschte Schnittstelle implementiert. Wir müssen uns nur darum kümmern, ob der Code von Drittanbietern die Schnittstelle implementiert, und wir müssen uns überhaupt nicht darum kümmern, wie der Code von Drittanbietern diese Schnittstellen implementiert. Schauen wir uns ein Beispiel aus der Praxis an.

Angenommen, ich gehe nach Miami, Florida, um an der Sunshine PHP Developer Conference teilzunehmen. Da ich die Stadt erkunden wollte, ging ich direkt zur örtlichen Autovermietung. Sie hatten einen modernen Kleinwagen, einen Subaru Kombi und (zu meiner Überraschung) einen Bugatti Veyron. Ich wusste, dass ich nur ein Fortbewegungsmittel brauchte, um mich in der Stadt fortzubewegen, und alle drei dieser Fahrzeuge würden meinen Bedürfnissen entsprechen. Aber jedes Auto ist so anders. Der Hyundai Accent ist nicht schlecht, aber ich mag etwas Dynamischeres. Da ich keine Kinder habe, ist der Kombi noch etwas groß. Also, okay, entscheiden Sie sich einfach für Bugatti.

Die Realität ist, dass ich jedes dieser drei Autos problemlos fahren kann, weil sie alle eine gemeinsame, bekannte Schnittstelle haben. Jedes Auto hat ein Lenkrad, ein Gaspedal, ein Bremspedal und Blinker, und jedes Auto verwendet Benzin als Kraftstoff. Aber die Leistung des Bugatti ist so stark, dass ich damit nicht zurechtkomme, aber die Fahrschnittstelle des modernen Autos ist genau die gleiche. Da alle drei Autos die gleiche bekannte Schnittstelle haben, habe ich die Möglichkeit, das Modell auszuwählen, das mir besser gefällt (um ehrlich zu sein, werde ich mich am Ende wahrscheinlich für Hyundai entscheiden).

Das gleiche Konzept gilt für die objektorientierte Seite von PHP. Wenn mein Code Objekte einer bestimmten Klasse verwendet (die eine bestimmte Implementierung darstellen), wird die Funktionalität meines Codes sehr eingeschränkt, da er für immer nur Objekte dieser Klasse verwenden kann. Wenn mein Code jedoch eine Schnittstelle verwenden soll, weiß mein Code sofort, wie er jedes Objekt verwenden soll, das die Schnittstelle implementiert. Mein Code kümmert sich überhaupt nicht darum, wie die Schnittstelle implementiert wird. Mein Code kümmert sich nur darum, ob das Objekt die Schnittstelle implementiert.

Angenommen, wir haben eine PHP-Klasse namens DocumentStore, die Daten von einer Remote-Adresse abrufen oder Daten aus dem Dokumentstrom lesen kann die Befehlszeilenausgabe des Terminals. Jedes in einer DocumentStore-Instanz gespeicherte Dokument verfügt über eine eindeutige ID. Beispiel 2-6 zeigt die DocumentStore-Klasse.

Beispiel 2-6 Definition der DocumentStore-Klasse

class DocumentStore
{
    protected $data = [];

    public function addDocument(Documentable $document)
    {
        $key = $document->getId();
        $value = $document->getContent();
        $this->data[$key] = $value;
    }

    public function getDocuments()
    {
        return $this->data;
    }
}

Wie können wir das oben Gesagte erreichen, wenn die addDocument-Methode nur Instanzen von empfängt? Dokumentierbare Klasse als Parameter? Beschreiben Sie die Funktion? Sehr gut im Beobachten. Tatsächlich ist Documentable keine Klasse, sondern eine Schnittstelle. Schauen Sie sich die Definition der Schnittstelle in Beispiel 2-7 an

Beispiel 2-7 Die Definition der Schnittstelle Documentable

interface Documentable
{
    public function getId();
    public function getContent();
}

In der Definition der Schnittstelle können wir sehen, dass jedes Objekt, das die Documentable-Schnittstelle implementiert, eine öffentliche getId()-Methode und eine öffentliche getContent()-Methode definieren muss.

Was sind also die Vorteile davon? Der Vorteil besteht darin, dass wir mehrere Dokumenterfassungsklassen mit unterschiedlichen Funktionen erstellen können. Beispiel 2-8 zeigt eine Schnittstellenimplementierung, die über Curl HTML von einer Remote-Adresse erhält.

Beispiel 2-8 Definition der HtmlDocument-Klasse

<?php
class HtmlDocument implements Documentable
{
    protected $url;

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

    public function getId()
    {
        return $this->url;
    }

    public function getContent()
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
        curl_setopt($ch, CURLOPT_MAXREDIRS, 3);
        $html = curl_exec($ch);
        curl_close($ch);

        return $html;
    }
}

Eine andere Implementierung (Beispiel 2-9) kann den angegebenen Ressourcendatenfluss lesen In .

Beispiel 2-9 Definition der StreamDocument-Klasse

<?php
class StreamDocument implements Documentable
{
    protected $resource;
    protected $buffer;

    public function __construct($resource, $buffer = 4096)
    {
        $this->resource = $resource;
        $this->buffer = $buffer;
    }

    public function getId()
    {
        return 'resource-' . (int)$this->resource;
    }

    public function getContent()
    {
        $streamContent = '';
        rewind($this->resource);
        while (feof($this->resource) === false) {
            $streamContent .= fread($this->resource, $this->buffer);
        }

        return $streamContent;
    }
}

Die letzte Implementierung (Beispiel 2-10) kann einen Terminalbefehl ausführen und ein Ausführungsergebnis erhalten

Beispiel 2-10 Definition der CommandOutputDocument-Klasse

<?php
class CommandOutputDocument implements Documentable
{
    protected $command;

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

    public function getId()
    {
        return $this->command;
    }

    public function getContent()
    {
        return shell_exec($this->command);
    }
}

Beispiel 2-11 zeigt, wie wir die DocumentStore-Klasse verwenden, um das von uns implementierte Documentable zu betreiben drei Dokumentensammlungsklassen der Schnittstelle

Beispiel 2-11 DocumentStore

<?php
$documentStore = new DocumentStore();

// Add HTML document
$htmlDoc = new HtmlDocument(&#39;http://php.net&#39;);
$documentStore->addDocument($htmlDoc);

// Add stream document
$streamDoc = new StreamDocument(fopen('stream.txt', 'rb'));
$documentStore->addDocument($streamDoc);

// Add terminal command document
$cmdDoc = new CommandOutputDocument('cat /etc/hosts');
$documentStore->addDocument($cmdDoc);

print_r($documentStore->getDocuments());

Das größte Highlight dabei ist, dass neben der Schnittstelle auch die HtmlDocument-, StreamDocument- und CommandOutputDocument-Klassen Abgesehen von der Konsistenz sind andere Aspekte völlig unterschiedlich.

Heutzutage erzeugen Programmierschnittstellen flexibleren Code, und wir kümmern uns nicht mehr um die konkrete Implementierung, sondern überlassen diese Aufgaben anderen. Immer mehr Menschen (z. B. Ihre Kollegen, Benutzer Ihrer Open-Source-Projekte oder Entwickler, die Sie noch nie getroffen haben) können Code schreiben, der nahtlos mit Ihnen zusammenarbeitet, und sie müssen lediglich die Just-Schnittstelle verstehen.

Das Obige stellt [Modernes PHP] vor, Kapitel 2, neue Funktionen, 2 schnittstellenbasierte Programmierung, einschließlich inhaltlicher Aspekte. Ich hoffe, es wird für Freunde hilfreich sein, die sich für PHP-Tutorials interessieren.