Das Entwerfen von Anwendungsprogrammierschnittstellen (APIs) kann ein herausforderndes Unterfangen sein. Gute APIs haben einfache Schnittstellen, die einfach und einfach zu bedienen sind. Hinter dieser einfachen Schnittstelle kann viele komplexe Systeminteraktionen sein, und diese Interaktionen können das Wasser einer ansonsten klar definierten Endpunktaufgabe wirklich schlammigen. Im Laufe der Zeit können Entwickler gebeten werden, die zusätzliche Geschäftslogik für bestehende Endpunkte zu „annehmen“. Bevor Sie es wissen, führt ein einzelner API -Aufruf als Teil ihres Hauptflusss Interaktionen mit über einem Dutzend Systemen durch.
Wäre es nicht schön, wenn wir eine unkomplizierte Pipeline entwickeln könnten, aber mit der Fähigkeit, später zusätzliche Aufgaben hinzuzufügen, ohne den Hauptfluss zu verdecken? Dieser Artikel zeigt Ihnen, wie Sie eine Idee von WordPress und die Programmierung im Allgemeinen anpassen können, um Ihren APIs die Möglichkeit zu geben, leistungsfähigere Interaktionen durchzuführen.
Die Idee hinter Hooks ist nichts Neues und wurde von WordPress nicht erfunden. WordPress hat sie jedoch bei ihrem Server-Side-Side-Verarbeitungslebenszyklus implementieren. Diese Verwendung von Hooks ist meiner Meinung nach wahrscheinlich die größte einzelne Funktion, die die Plattform hat. Mit diesen Hooks können Benutzer ihre eigene Funktionalität schreiben - sei es Plugins oder Themen -, die in WordPress zusammenhängen und den von Ihnen gewünschten Code ausführen, wenn er benötigt wird. Müssen Sie einen an den Benutzer gesendeten Header ändern? Kein Problem: Haken Sie sich in das Ereignis wp_Headers ein und Sie können die Header nach Belieben ändern.
Hooks eignen sich für viele Dinge, einschließlich Auslösen einiger Nebenaufgaben, Aufrufen von einem anderen System über einen PHP -Curl -Befehl, das Erstellen eines Objekts und das Einbinden in eine Task -Warteschlange, die später von einem anderen System aufgegriffen werden soll, um eine E -Mail zu senden. und mehr. Dies alles kann geschehen, ohne den Hauptfluss eines bestimmten Endpunkts zu trüben (und möglicherweise eine neue API -Version zu erzwingen).
Wenn der Endpunkt für das Erstellen eines Benutzers bestimmt ist, können wir uns darauf konzentrieren, diesen Benutzerdatensatz in der Datenbank zu erstellen und auf dem Weg einfach zu dem zu hören, wer während dieses Prozesses zuhört. Vielleicht senden wir nach dem Erstellen des Benutzerdatensatzes ein Ereignis mit der Aufschrift "Jeder, der dies hört, ich habe gerade einen Benutzer erstellt und hier sind seine Informationen." Vielleicht haben einige Rückruffunktionen das Ereignis abonniert und zuhören oder vielleicht keine. Die Veranstaltung ist es egal.
Mit diesem System können wir unsere APIs zum Code rufen, der möglicherweise zu einem späteren Zeitpunkt geschrieben wird. Wir können dies tun, ohne den API -Endpunktcode selbst zu berühren. Um zu demonstrieren, wie dies funktionieren könnte, wechseln wir den Gang und zeigen den grundlegenden Mechanismus, wie wir dies in einer PHP -API beginnen können. Beachten Sie, dass wir, während wir PHP hier verwenden, eine ähnliche Logik in Webanwendungen mit anderen Sprachen implementieren können.
Um loszulegen, müssen wir in der Lage sein, einen Hook/eine Aktion hinzuzufügen (die ich von nun an als "Hook" bezeichnen werde). Wir müssen auch einen Haken entfernen und zuletzt einen Haken auslösen. Sobald wir diese Mechanismen definiert haben, müssen wir nur sicherstellen, dass sie in die API einbezogen sind und dann Orte in unserer API lokalisieren, an denen wir diese Haken nennen möchten. Im Folgenden möchten wir dies vielleicht einrichten.
Hier ist Hooks.php:
<span>// Global array which will hold all of our hooks
</span><span>// We will reference this array in each function to add/remove/call our hooks
</span><span>// The code below should also be seen by any callbacks we write for the system later.
</span><span>$hooks = [];
</span>
<span>// Below are global functions that can be seen from our API code
</span><span>// The add_hook method will allow us to attach a function (callback) to a given event name
</span><span>function add_hook($event_name, $callback) {
</span> <span>global $hooks;
</span>
<span>if ($callback !== null) {
</span> <span>if ($callback) {
</span> <span>// We can set up multiple callbacks under a single event name
</span> <span>$hooks[$event_name][] = $callback;
</span> <span>}
</span> <span>}
</span><span>}
</span>
<span>// Super easy to implement, we remove the given hook by its name
</span><span>function remove_hook($event_name) {
</span> <span>global $hooks;
</span>
<span>unset($hooks[$event_name]);
</span><span>}
</span>
<span>// When we want to trigger our callbacks, we can call this function
</span><span>// with its name and any parameters we want to pass.
</span><span>function do_hook($event_name, ...$params) {
</span> <span>global $hooks;
</span>
<span>if (isset($hooks[$event_name])) {
</span> <span>// Loop through all the callbacks on this event name and call them (if defined that is)
</span> <span>// As we call each callback, we given it our parameters.
</span> <span>foreach ($hooks[$event_name] as $function) {
</span> <span>if (function_exists($function)) {
</span> <span>call_user_func($function, ...$params);
</span> <span>}
</span> <span>}
</span> <span>}
</span><span>}
</span>Jetzt, da wir unsere Datei hooks.php erstellt haben, müssen wir sie lediglich in unsere API einbeziehen, damit diese Funktionen gesehen werden können. Sobald dies erledigt ist, geht es nur darum, die Haken mit Do_Hook in unsere API einzuführen.
Nehmen wir als einfaches Beispiel an, wir haben eine API für die Registrierung eines neuen Benutzers mit unserem System. Möglicherweise haben wir einen REST -API -Endpunkt namens /Adduser. Nehmen wir auch im Namen der Einfachheit an, dass das Ziel hier darin besteht, einfach den Namen und das Alter eines neuen Benutzers in die Benutzertabelle unserer Datenbank einzufügen. Ziemlich direkt, oder?
<span>// Global array which will hold all of our hooks
</span><span>// We will reference this array in each function to add/remove/call our hooks
</span><span>// The code below should also be seen by any callbacks we write for the system later.
</span><span>$hooks = [];
</span>
<span>// Below are global functions that can be seen from our API code
</span><span>// The add_hook method will allow us to attach a function (callback) to a given event name
</span><span>function add_hook($event_name, $callback) {
</span> <span>global $hooks;
</span>
<span>if ($callback !== null) {
</span> <span>if ($callback) {
</span> <span>// We can set up multiple callbacks under a single event name
</span> <span>$hooks[$event_name][] = $callback;
</span> <span>}
</span> <span>}
</span><span>}
</span>
<span>// Super easy to implement, we remove the given hook by its name
</span><span>function remove_hook($event_name) {
</span> <span>global $hooks;
</span>
<span>unset($hooks[$event_name]);
</span><span>}
</span>
<span>// When we want to trigger our callbacks, we can call this function
</span><span>// with its name and any parameters we want to pass.
</span><span>function do_hook($event_name, ...$params) {
</span> <span>global $hooks;
</span>
<span>if (isset($hooks[$event_name])) {
</span> <span>// Loop through all the callbacks on this event name and call them (if defined that is)
</span> <span>// As we call each callback, we given it our parameters.
</span> <span>foreach ($hooks[$event_name] as $function) {
</span> <span>if (function_exists($function)) {
</span> <span>call_user_func($function, ...$params);
</span> <span>}
</span> <span>}
</span> <span>}
</span><span>}
</span>Der obige Code ist eine übermäßig vereinfachende und verallgemeinerte Ansicht, wie wir einen neuen Benutzer hinzufügen könnten. Die Idee ist, dass jemand, wenn jemand den Endpunkt unserer API /Adduser anrufen würde, irgendwann zu dieser Funktion gelangen würde, bei der der Name und das Alter des Benutzers aus den veröffentlichten Daten herausgezogen werden. Wir überprüfen zunächst, um sicherzustellen, dass sie veröffentlichen (wie die ordnungsgemäßen REST -Regeln vorschreiben) und dann versuchen, den Benutzer in die Benutzertabelle einzufügen.
Als nächstes möchten wir, wenn der Benutzer erfolgreich eingefügt wurde, einen Haken anrufen, damit ein Code zuhört, den ein Benutzer erstellt wurde (dies ähnelt der Erhöhung eines Ereignisses in anderen Sprachen).
Einige Monate später haben wir unsere Marketingabteilung darauf, dass beim Erstellen eines neuen Benutzers eine E -Mail mit den Details des Benutzers gesendet werden sollte. Wir könnten geneigt sein, eine Helferfunktion in die API zu schreiben und sie dann von diesem Endpunktcode aus aufzurufen. Großartig ... wenn das alles angefordert wurde. Aber was ist, wenn das Support -Team später zu Ihnen kommt und dass Sie den Benutzer auch zu seinem Zendesk -System hinzufügen? Sie schreiben also eine weitere Funktion und stellen diesen Endpunkt auch in diesen Endpunkt ein.
Als nächstes wissen Sie, dass dieser Endpunkt nicht nur einen Benutzer zu unserer Website -Datenbank hinzufügt, sondern auch Anrufe bei Funktionen zum Senden von E -Mails, Benutzer zu Zendenk, JIRA und Microsoft Cloud und dann mit ihren Erfolgs-/Fehlerergebnissen hinzugefügt wird. All diese zusätzlichen Sachen nehmen wirklich den klaren Punkt, den Benutzer in unsere Datenbank hinzuzufügen. Wir möchten ein Ereignis anrufen und einen anderen Code nur zuhören lassen, wenn ein Benutzer erstellt wird und seine eigenen Dinge erledigt - ohne dass wir diesen Endpunkt ändern müssen. Vielleicht kümmert sich keine anderen Dienste um das Hinzufügen eines neuen Benutzers, daher ist niemand aufgefordert, etwas zu tun. Der Endpunkt muss sich nicht darum kümmern. Ziemlich toll, oder?
Lassen Sie uns unser Beispiel fortsetzen, indem Sie unserem Haken einen Namen geben. Dies ist der Name, den alle Callback -Code zum Anhören verwenden müssen. Auch hier bezeichnen andere Sprachen dieses Setup als „Ereignisse“. Sehen Sie sich also unbedingt in Ihrer gegebenen Sprache nach, um mehr zu erfahren.
wir nennen unseren Hook addle_user. Einfach und direkt auf den Punkt, denkst du nicht? Sobald wir einen Namen haben, können wir entscheiden, wo wir diesen Haken nennen möchten. Ich denke, gleich nach einem erfolgreichen Einsatz wäre eine gute Idee:
<span>// POST endpoint for adding a user (part of a larger API class)
</span><span>public function addUser($name, $age) {
</span> <span>if ($this->request->method === 'post') {
</span> <span>try {
</span> <span>$this->db->insert('users', ['name' => $name, 'age' => $age]);
</span> <span>return new Response(200, 'User created successfully!');
</span> <span>} catch (Exception $e) {
</span> <span>// Oops, something went wrong.
</span> <span>// Do some logging or whatever.
</span> <span>}
</span> <span>}
</span>
<span>// If not a POST request, return http status 400
</span> <span>return new Response(400, 'Bad request');
</span><span>}
</span>Jetzt können wir Dutzende von Rückruffunktionen haben, die den adata_user -Hook oder gar keine anhören. Vielleicht haben wir einen Rückruf, der dafür verantwortlich ist, den Benutzer in Zendesk einzuführen, und einen anderen, der den Namen und das Alter aufnimmt und eine E -Mail an das Marketing generiert. Dieser „Abonnenten“ -Coder kann woanders in der Codebasis leben, solange er den Code von Hooks.php im API -Projekt sehen kann. Normalerweise stelle ich meine Rückruffunktion in eine separate Datei ein und füge diese Datei auch in die API ein. Im Folgenden finden Sie ein Beispiel für einen Rückruf, der jetzt diesen neuen Hook nutzen kann, den wir erstellt haben:
<span>// Global array which will hold all of our hooks
</span><span>// We will reference this array in each function to add/remove/call our hooks
</span><span>// The code below should also be seen by any callbacks we write for the system later.
</span><span>$hooks = [];
</span>
<span>// Below are global functions that can be seen from our API code
</span><span>// The add_hook method will allow us to attach a function (callback) to a given event name
</span><span>function add_hook($event_name, $callback) {
</span> <span>global $hooks;
</span>
<span>if ($callback !== null) {
</span> <span>if ($callback) {
</span> <span>// We can set up multiple callbacks under a single event name
</span> <span>$hooks[$event_name][] = $callback;
</span> <span>}
</span> <span>}
</span><span>}
</span>
<span>// Super easy to implement, we remove the given hook by its name
</span><span>function remove_hook($event_name) {
</span> <span>global $hooks;
</span>
<span>unset($hooks[$event_name]);
</span><span>}
</span>
<span>// When we want to trigger our callbacks, we can call this function
</span><span>// with its name and any parameters we want to pass.
</span><span>function do_hook($event_name, ...$params) {
</span> <span>global $hooks;
</span>
<span>if (isset($hooks[$event_name])) {
</span> <span>// Loop through all the callbacks on this event name and call them (if defined that is)
</span> <span>// As we call each callback, we given it our parameters.
</span> <span>foreach ($hooks[$event_name] as $function) {
</span> <span>if (function_exists($function)) {
</span> <span>call_user_func($function, ...$params);
</span> <span>}
</span> <span>}
</span> <span>}
</span><span>}
</span>Im obigen Code demonstrieren wir die Verwendung eines Hakens in einem einzelnen Endpunkt. Dieser Haken wird nur ausgelöst, wenn der /adduser -Endpunkt aufgerufen wird und erst nach Erfolg des Einsatzes. Dies ist jedoch nicht der einzige Ort, an dem Sie diese Haken verwenden können. Vielleicht haben Sie einen Routing -Code in Ihrer API -Klasse, der überprüft wird, ob ein API -Schlüssel gültig ist oder dass Sie sogar eine bestimmte Art von Anforderung erhalten haben.
Sie könnten einen Haken auf globaler Ebene innerhalb der API einfügen, damit jede Anfrage ihn auslöst. Dann, zu einem späteren Zeitpunkt, konnte jemand einen Logger schreiben, ihn an den von Ihnen erstellten API_init -Haken anhängen und plötzlich alle Anfragen an die API protokollieren - erneut, ohne den Code der Haupt -API -Klasse zu berühren. Der gleiche Haken kann auch einen zusätzlichen Rückruf beigefügt haben, der nach API -Missbrauch nachgibt und diese Ihrer Informationstechnologieabteilung meldet, wenn jemand Ihre API mit Anfragen schlägt.
Das Bild unten ist ein Diagramm darüber, wie dies alles architektonisch aussieht.
Da Sie diesen Mechanismus an mehreren Stellen verwenden können, können Sie sogar Haken am Anfang, in der Mitte und am Ende eines API -Endpunkts haben. Sie könnten auch Haken an verschiedenen Stellen des gesamten API -Lebenszyklus bei der Behandlung einer Anfrage haben. Es liegt wirklich an Ihrem Design, wo Sie diese do_hook -Anrufe einfügen.
Lassen Sie uns jetzt einige Best Practices für Sie und Ihre Entwickler abdecken.
Eine Sache, die Sie beachten sollten, ist, dass diese Hooks immer noch zum Code rufen, der im einzelnen Thread ausgeführt wird. Wenn Sie nicht in Ihrem Rückruf etwas ausgelöst werden, das die Aufgabe in einen Hintergrundprozess oder einen anderen Dienst bringt, wird in der API weiterhin dieser zusätzliche Code ausgeführt (wenn der Haken ausgelöst wird). Dies bedeutet, dass wir unser Bestes tun sollten, um jeden Rückrufcode schlank und gemein zu halten. Der langjährige Rückrufcode wird die Endpunkte oder die API insgesamt verlangsamen.
Mit der Art und Weise, wie diese Struktur entworfen wurde, ist es einfach, Rückruffunktionen für Ihre Hooks hinzuzufügen und zu entfernen, und das Debuggen ist genauso einfach. Finden Sie heraus, welcher Rückruf der Täter ist (möglicherweise haben Sie jeden Rückruf einige Daten) und finden Sie heraus, wo er stecken bleibt. Lassen Sie es dann einfach nicht den Haken abonnieren, bis der Fehler behoben ist, oder über den Callback -Code arbeiten, wobei dies erneut im Endpoint/API -Code berührt und nicht verhindert, dass Ihr API -Code in der Produktion ausgeführt wird.
Es ist auch wichtig, sich darüber im Klaren zu haben, wie viele Rückrufe Sie an Ihren Haken anhängen. Eine Handvoll schneller Rückrufe ist in Ordnung, aber 100 Rückrufe an einem einzigen Haken, wobei jede Ausführung eine Sekunde dauert, können wirklich ein Zug Ihrer API sein. Wir möchten schnelle API -Anrufe, und jeder Rückruf kann leicht auf die Antwortzeiten ziehen. Wenn Sie einen Rückruf langsam finden, werfen Sie die Aufgabe zu einem Hintergrundprozess oder einem Warteschlangensystem, das später von einem anderen Dienst abgeholt werden soll. Ich verwende oft Jobs in Systemen wie Laravel, um solche Aufgaben zu erledigen. Fügen Sie möglicherweise die Benutzeraufgabe einer Laravel -Jobwarteschlange hinzu und fahren Sie mit der API -Verarbeitung fort.
Stellen Sie schließlich sicher, dass Sie mit Ihren Entwicklern, die diese Haken verwenden, in Kontakt bleiben. Es ist üblich, dass Entwickler, die Ihre Haken verwenden und Rückrufe schreiben, nicht die gleichen Personen sind, die zunächst den Haken in der API erstellt haben. Wenn Ihre API reift, können Sie Anfragen sehen, um mehr Haken an verschiedenen Stellen und mit einer feineren Granularität hinzuzufügen. Sie könnten nach/nach Hooks fragen, die verwendet werden können, um Aktionen auszulösen, bevor ein Benutzer ebenso eingefügt wird. Sie können auch nach zusätzlichen Informationen bitten, um an ihre Rückrufe weiterzugeben (beispielsweise nicht nur der Name und das Alter, sondern auch die neue ID des eingefügten Benutzers). Nehmen Sie diese Anfragen als gutes Zeichen dafür, dass Ihre Entwickler den Mechanismus nützlich finden, und sehen Sie das Potenzial, die Auswirkungen Ihrer API in verwandten Systemen zu erweitern. Es fühlt sich wirklich gut an, ein System zu haben, das so einfach ein kleines Stück Code zu „haken“ und ausführen kann, um einen großen Einfluss zu haben.
Mit diesem Ansatz ist die Himmel die Grenze für das, was Sie von Ihrer API haben können. Dies alles kann erreicht werden, während der Hauptfluss Ihres Endpunkts im Umgang mit anderen Systemen klar und frei von Lärm ist.
In diesem Artikel haben wir diskutiert, was Haken/Handlungen sind und wie sie verwendet werden könnten. Wir haben einen Beispiel -PHP -Code angegeben, den Sie in Ihrer PHP -API verwenden können, um „Hooking“ zu implementieren, und wie ein Rückruf verwendet werden kann, um diesen Haken zu binden. Wir haben auch darüber diskutiert, dass Hooks auf allgemeiner API -Ebene (weltweit für alle Anfragen) sowie in Endpunkten addiert werden. Darüber hinaus haben wir ein wenig über einige der Nachteile dieses Systems gesprochen und es ist eine gute Idee, Ihre Rückrufe schlank und gemein zu halten. Für den Fall, dass Sie einen langjährigen Rückruf haben, haben wir einige Strategien für den Umgang mit solchen Prozessen erwähnt, um zu verhindern, dass sie sich auf Ihre API-Pipeline auswirken.
Wenn Sie dieses System implementieren, können auch Sie einige der größten Funktionen gewinnen, die die WordPress -Community (und die Programmierer im Allgemeinen) seit Jahren genießen. Sie sparen sich auch viel Zeit und Kopfschmerzen daran, Ihren API -Code direkt zu ändern, und können sich stattdessen auf kleine Rückrufcode konzentrieren. Sie können auch Rückrufe hinzufügen und entfernen, die möglicherweise ganze Integrationen in andere Systeme sind. All diese Funktionen - und nicht ein einziges Mal, Ihren API -Pipeline -Code neu zu veröffentlichen! Das ist ein ziemlich gutes Geschäft, oder? Mit diesem System habe ich es geschafft, an einem Tag einige einfache Integrationen durchzuführen, und jetzt können Sie es auch tun.
Danke fürs Lesen!
Wie kann ich Hooks für meine PHP -API -Pipeline erstellen? Für Ihre PHP -API -Pipeline umfasst die Definition bestimmter Punkte in Ihrem Code, bei dem benutzerdefinierter Code ausgeführt werden kann. Dies erfolgt normalerweise mit Ereignissen und Zuhörern. Wenn ein bestimmtes Ereignis auftritt, wird der entsprechende Hörer ausgelöst, wodurch der benutzerdefinierte Code ausgeführt wird. Auf diese Weise können Sie das Verhalten Ihrer Anwendung zur Laufzeit ändern und ein hohes Maß an Flexibilität und Anpassungsfähigkeit bieten. mehrere Best Practices. Erstens ist es wichtig, die API einfach und intuitiv zu halten, was es den Entwicklern leicht macht, zu verstehen und zu verwenden. Zweitens sollte die API als erweiterbar ausgelegt sein, sodass neue Funktionen hinzugefügt werden können, ohne vorhandene Funktionen zu brechen. Drittens ist es entscheidend, klare und umfassende Dokumentation bereitzustellen und Entwicklern zu verstehen, wie sie die API effektiv verwenden können. Schließlich kann die Verwendung von Standard -HTTP -Methoden und Statuscodes die API vorhersehbarer und einfacher zu verwenden. Design aufgrund seiner Einfachheit und Flexibilität. Es unterstützt eine breite Palette von Datenformaten, einschließlich JSON und XML, wodurch es einfach ist, APIs zu erstellen, die von verschiedenen Kunden konsumiert werden können. PHP hat auch eine große und aktive Gemeinschaft, die Entwicklern eine Fülle von Ressourcen und Unterstützung bietet. Wie jede Sprache hat es jedoch seine Stärken und Schwächen, und die Sprachauswahl sollte auf den spezifischen Anforderungen des Projekts beruhen.
Wie kann ich die Sicherheit meiner API sicherstellen? Maßnahmen. Dies beinhaltet die Verwendung sicherer Kommunikationsprotokolle wie HTTPS, die Implementierung von Authentifizierungs- und Autorisierungsmechanismen sowie die Validierung und Bereinigung von Eingabedaten, um Injektionsangriffe zu verhindern. Regelmäßige Sicherheitsaudits und Updates können auch dazu beitragen, potenzielle Schwachstellen zu identifizieren und zu beheben.
Wie kann ich die Leistung meiner API verbessern? Caching und Verwendung effizienter Datenstrukturen und Algorithmen. Regelmäßige Leistungstests und -überwachung können dazu beitragen, Engpässe und Verbesserungsbereiche zu identifizieren. Aktualisieren des API -Designs basierend auf dem Feedback von Entwicklern und Änderungen der Geschäftsanforderungen. Es ist auch wichtig, Änderungen an den API -Nutzern rechtzeitig zu vermitteln und bei Bedarf ältere Versionen der API zu unterstützen.
.Das obige ist der detaillierte Inhalt vonFlexible API -Design: Erstellen Sie Hooks für Ihre PHP -API -Pipeline. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
