Einfache JSON-RPC-ähnliche API in PHP

Eintrag

Was ist die JSON-RPC-API? Dies ist nur einer der API-Typen, aber auch ein klarer Standard, der möglicherweise nicht in diesem Artikel enthalten ist (ja, es wird einen Samopis geben).

Nachdem ich eine Weile mit der RESTful-API herumgespielt und mich sehr darüber geärgert hatte, wie einfach sie außen ist und innen gefaltet werden kann, ging ich zu Google, um nach einem Ersatz zu suchen.

Ich stieß auf einen Artikel über die JSON-RPC-API und war sehr an ihrem Konzept interessiert, so dass ich mich entschied, mein Fahrrad so einfach wie möglich zu implementieren.

JSON-RPC-API-Konzept

Die Hauptidee dieses Standards liegt in einem bestimmten objektorientierten Ansatz.

Semantisch sieht die Abfrage folgendermaßen aus:

{ "api version": 0.1, "method": "object.method", "params": { "user id": 1234 } } 

Und dies ist nur eine Anfrage. Der große Reiz einer solchen API besteht darin, dass sie wunderbar kombiniert werden können, und dies gibt uns die Möglichkeit, sie für Batch-Anfragen zu verwenden (etwas in Teilen laden).

Das heißt, eine vollständige Anfrage kann so aussehen.

 { "api_v": "0.1", "reqs": [ { "name": "my_important_request", "method": "user.kick_out", "params": { "id": "1234", "when": "now", ... } }, ... ] } 

Hier ist api_v die API-Version und reqs ist ein Array von Anforderungen. Was wichtig ist, jede Anfrage hat eine Methode (class.method), Parameter und Namen. Der Name spielt hier eine große Rolle. Wenn Sie eine Antwort vom Server erhalten, können Sie anhand des Namens auf das Abfrageergebnis verweisen. Beispiel: Eine Anfrage mit einer Methode zum Hinzufügen eines Benutzers sollte "user_creating" heißen, aber das liegt bei Ihnen;)

Lass uns anfangen zu schreiben

Das erste, was getan werden muss, ist die API-Klasse, in meinem Fall sogar noch weniger als sie sollte. Einige Prozesse sind von mir getrennt, aber das ändert nichts an der Essenz.

 <?php // @package 'api_0.1.php' // API  0.1 class API { private $last_resp; //    private $resp = []; //   public function __call( $method, $params ) { //  ,     $object = substr($method, 0, strpos($method, '.')); $method_name = substr($method, strpos($method, '.')+1); //   include_once __DIR__.'/source/'.$object.'.methods.php'; //      $resp = $object::$method_name($params); if(!empty($resp)) $this->last_resp = $resp; else $this->last_resp = null; } //          - pulbic function add_resp($req_name){ if($this->last_resp === null) return false; $req = $this->last_resp; $this->resp[$req_name] = $req; } //  ,    public function response(){ exit ( json_encode($this->resp) ); } } 

Der Code enthält Kommentare, aber hier ist ein kurzer Exkurs ... Wir nennen die API eine unbekannte Funktion. Verwenden Sie für diese Zwecke die Funktion magic __call. Das heißt, durch Aufrufen der Funktion "Object.method" der API ($ api -> {"Object.method"}) wird die Zeichenfolge automatisch in ein Paar von Objektmethoden aufgeteilt und aufgerufen. Danach werden die Ergebnisse aller Abfragen zu einem Array hinzugefügt und im JSON-Format zurückgesendet. Alles ist einfach.

Klassen

Es ist sehr wichtig - hier werden die Klassen im Quellordner gespeichert und so sollte die Klasse aussehen

 <?php class object{ function method($params){ /* ... */ } } 

Der Klassenname muss mit dem in der Anforderung angeforderten übereinstimmen, genau wie der Methodenname. Alles andere spielt keine Rolle. Eine Methode kann alles tun und alles zurückgeben.

Wir brauchen aber auch ein Kontrollskript. Dies ist das gleiche Skript, das auf Anfrage aufgerufen wird.

 <?php // @package api.php header('Content-Type: application/json'); //     json $api_v = $_POST['api_v']; // $path = __DIR__.'/APIs/api_'.$api_v.'.php'; //       ,    if(!file_exists($path)) exit; //       include_once __DIR__.'/APIs/api_'.$api_v.'.php'; //  API $api = new API(); $reqs = $_POST['reqs']; $reqs = @json_decode($reqs, true); //  json  php  () //    ,          API foreach ($reqs as $req) { $method = $req['method']; $params = $req['params']; $req_name = $req['name']; $api->$method($params); $api->add_resp($req_name); } //    $api->response(); 

Was ist hier los? Wir aktivieren unsere API abhängig von der in der Anfrage angegebenen Version. Wir dekodieren JSON-Anfragen und gehen jede durch. Wir rufen die API-Methode vom Typ "object.method" auf und speichern ihr Ergebnis unter dem Namen dieser Anfrage (es wurde oben geschrieben, dass jede Anfrage ihren eigenen Namen hat). Nachdem wir alle Anforderungen ausgeführt haben, geben wir ein JSON-Array von Ergebnissen zurück ... Und im Grunde ist es das.

Kleine js

Hier ist ein kleines Beispiel für eine Funktion in js, die API-Anforderungen dieses Typs erstellt. Es wurde mit jQuery geschrieben und ich entschuldige mich wild bei Ihnen dafür, aber es ist so einfacher, die Essenz ohne zu viel zu zeigen.

 function api_call(reqs, callback){ //  (  ,    ,     )   json var json = JSON.stringify( (Array.isArray(reqs) ? reqs : [reqs]) ); //  POST  $.post({ url: '/api/api.php', //    api.php dataType: 'json', //   json,     data: ({ api_v: '0.1', reqs: json }), //   API   ( json ) success: function(res){ //         window,      .     for(var key in res){ window.loaded[key] = res[key]; } //      callback(res); } }); } 

Hier ist eine einfache POST-Anfrage, und es gibt fast nichts Besonderes, außer dass es möglich ist, nur eine Anfrage und kein Array anzugeben. Außerdem speichere ich alle Antworten in einem Array heruntergeladener Anfragen. Der Einfachheit halber ist dies überhaupt nicht erforderlich.

Nun, ich hoffe, die Hauptidee ist Ihnen klar. Ich wollte eine einfache und intuitive API erstellen - das habe ich getan. Zum größten Teil wollte ich diesen einfachen Ansatz zum Erstellen einer multifunktionalen API zeigen.

Bis bald…