API simples do tipo JSON-RPC em PHP

Entrada

O que é a API JSON-RPC? Esse é apenas um dos tipos de API, mas também um padrão claro, que pode não estar neste artigo (sim, haverá uma amostra).

Depois que eu brinquei com a API RESTful por um tempo e fiquei muito bravo com ela, por como é simples por fora e pode ser dobrada por dentro, fui ao google em busca de uma substituição.

E me deparei com um artigo sobre a API JSON-RPC e fiquei muito interessado em seu conceito, tanto que decidi implementar minha bicicleta o mais simples possível.

Conceito de API JSON-RPC

A idéia principal desse padrão está em uma certa abordagem orientada a objetos.

Semanticamente, a consulta fica assim:

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

E essa é apenas uma solicitação, o grande charme de uma API desse tipo é que elas podem ser combinadas com perfeição e isso nos dá a oportunidade de usá-la para solicitações em lote (carregue algo em partes).

Ou seja, uma solicitação completa pode ser assim.

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

Aqui api_v é a versão da API e reqs é uma matriz de solicitações. O que é importante, cada solicitação possui um método (class.method), parâmetros e nome. O nome desempenha um grande papel aqui. Quando você recebe uma resposta do servidor, pode consultar o resultado da consulta pelo nome. Exemplo: uma solicitação com um método para adicionar um usuário deve ser chamada "user_creating", mas isso é com você;)

Vamos começar a escrever

A primeira coisa que precisa ser feita é a classe API, no meu caso, faz ainda menos do que deveria. Alguns processos são separados de mim, mas isso não muda a essência.

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

Existem comentários no código, mas aqui está uma breve digressão ... Chamamos a API de função desconhecida, use a função __call mágica para esses fins. Ou seja, chamando a função "Object.method" da API ($ api -> {"Object.method"}), ele divide automaticamente a string em um par objeto-método e a chama. Depois disso, os resultados de todas as consultas são adicionados a uma matriz e são enviados de volta no formato json. Tudo é simples.

Aulas

É muito importante - aqui as classes são armazenadas na pasta de origem e é assim que a classe deve ficar

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

O nome da classe deve corresponder ao que é solicitado na solicitação, o mesmo com o nome do método. Todo o resto não importa. Um método pode fazer qualquer coisa e retornar qualquer coisa.

Mas também precisamos de um script de controle. Este é o mesmo script que será chamado mediante solicitação.

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

O que está acontecendo aqui? Ativamos nossa API dependendo da versão especificada na solicitação. Decodificamos pedidos json e passamos por cada um deles. Chamamos o método API do tipo "object.method" e salvamos seu resultado com o nome dessa solicitação (foi escrito acima que cada solicitação tem seu próprio nome). Após executar todas as solicitações, retornamos uma matriz json de resultados ... E, basicamente, é isso.

Little js

Aqui está um pequeno exemplo de uma função em js que fará solicitações de API desse tipo. Ele foi escrito usando jQuery, e peço desculpas por isso, mas é muito mais simples mostrar a essência sem muito.

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

Aqui está uma solicitação POST simples, e quase não há nada de especial, exceto que é possível especificar apenas uma solicitação, não uma matriz, e também guardo todas as respostas em uma matriz de solicitações baixadas, é apenas que, por conveniência, não é de todo necessário.

Bem, espero que a idéia principal esteja clara para você. Eu queria criar uma API simples e intuitiva - fiz. Na maioria das vezes, eu queria mostrar uma abordagem tão simples para criar uma API multifuncional.

Até breve ...