API simple similar a JSON-RPC en PHP

Entrada

¿Qué es la API JSON-RPC? Este es solo uno de los tipos de API, pero también un estándar claro, que puede no estar en este artículo (sí, habrá un samopis).

Después de jugar un rato con la API RESTful y me enojé mucho con ella, por lo simple que es por fuera y se puede plegar por dentro, fui a google en busca de un reemplazo.

Y me encontré con un artículo sobre la API JSON-RPC, y estaba muy interesado en su concepto, tanto que decidí implementar mi bicicleta lo más simple posible.

Concepto de API JSON-RPC

La idea principal de este estándar está en un cierto enfoque orientado a objetos.

Semánticamente, la consulta se ve así:

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

Y esta es solo una solicitud, el gran encanto de tal API es que pueden combinarse maravillosamente, y esto nos da la oportunidad de usarla para solicitudes por lotes (cargar algo en partes).

Es decir, una solicitud completa puede verse así.

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

Aquí api_v es la versión de API, y reqs es una matriz de solicitudes. Lo que es importante, cada solicitud tiene un método (class.method), parámetros y nombre. El nombre juega un papel importante aquí. Cuando recibe una respuesta del servidor, puede consultar el resultado de la consulta por su nombre. Ejemplo: una solicitud con un método para agregar un usuario debe llamarse "user_creating", pero esto depende de usted;)

Vamos a empezar a escribir

Lo primero que hay que hacer es la clase API, en mi caso hace incluso menos de lo que debería. Algunos procesos están separados de mí, pero esto no cambia la esencia.

 <?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) ); } } 

Hay comentarios en el código, pero aquí hay una breve digresión ... Llamamos a la API una función desconocida, use la función mágica __call para estos fines. Es decir, al llamar a la función "Object.method" de la API ($ api -> {"Object.method"}), divide automáticamente la cadena en un par de objeto-método y la llama. Después de eso, los resultados de todas las consultas se agregan a una matriz y se devuelve en formato json. Todo es simple

Clases

Es muy importante: aquí las clases se almacenan en la carpeta de origen y así es como debería verse la clase

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

El nombre de la clase debe coincidir con lo que se solicita en la solicitud, lo mismo con el nombre del método. Todo lo demás no importa. Un método puede hacer cualquier cosa y devolver cualquier cosa.

Pero también necesitamos un script de control. Este es el mismo script que se llamará a pedido.

 <?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(); 

¿Qué está pasando aquí? Habilitamos nuestra API según la versión especificada en la solicitud. Decodificamos solicitudes json y revisamos cada una de ellas. Llamamos al método API de tipo "object.method" y guardamos su resultado con el nombre de esta solicitud (se escribió anteriormente que cada solicitud tiene su propio nombre). Después de ejecutar todas las solicitudes, devolvemos una matriz json de resultados ... Y, básicamente, eso es todo.

Pequeño js

Aquí hay un pequeño ejemplo de una función en js que realizará solicitudes de API de este tipo. Está escrito usando jQuery, y le pido disculpas por esto, pero es más simple mostrar la esencia sin demasiado.

 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); } }); } 

Aquí hay una simple solicitud POST, y no hay casi nada especial, excepto que es posible especificar solo una solicitud, no una matriz, y también guardo todas las respuestas en una matriz cargada, es solo eso, por conveniencia, no es del todo necesario.

Bueno, espero que la idea principal sea clara para ti. Quería hacer una API simple e intuitiva, lo hice. En su mayor parte, quería mostrar un enfoque tan simple para crear una API multifuncional.

Hasta pronto ...