Näide API-le juurdepääsust php-s. RESTful API loomine PHP-s

Projekti arendades seisin silmitsi vajadusega korraldada iOS-i ja Android-platvormil olevate rakenduste vahel kliendi-serveri suhtlus oma veebisaidiga, kuhu salvestati kogu teave - tegelik mysql-i andmebaas, pildid, failid ja muu sisu.
Probleemid, mis vajasid lahendamist, olid üsna lihtsad:
kasutaja registreerimine/volitamine;
teatud andmete (näiteks toodete nimekirja) saatmine/vastuvõtmine.

Ja siis tahtsin serveri poolega suhtlemiseks kirjutada oma API - peamiselt praktilise huvi pärast.

Sisendandmed

Minu käsutuses oli:
Server – Apache, PHP 5.0, MySQL 5.0
Klient – ​​Android, iOS seadmed, mis tahes brauser

Otsustasin, et kasutan JSON-i andmevormingut serverile saadetavate päringute ja sealt saadavate vastuste jaoks – selle lihtsuse ning PHP ja Androidi algse toe tõttu. Siin häiris iOS mind - sellel pole loomulikku JSON-i tuge (siin pidin kasutama kolmanda osapoole arendust).

Samuti otsustati, et päringuid saab saata nii GET kui POST päringu kaudu (siin aitas PHP-s $_REQUEST). See lahendus võimaldas testida API-d GET-päringute kaudu mis tahes saadaolevas brauseris.

Otsustati teha päringute välimus selline:
http://[serveri aadress]/[api kausta tee]/?[api_nimi].[meetodi_nimi]=

Api kausta tee on kataloog, kuhu peate tegema päringuid, mille juureks on fail index.php - see vastutab funktsioonide helistamise ja vigade käsitlemise eest
Nimetus api - mugavuse huvides otsustasin eraldada API rühmad - kasutaja, andmebaas, sisu jne. Sel juhul sai iga API oma nime
Meetodi nimi – meetodi nimi, mida tuleb määratud API-s kutsuda
JSON – JSON-objekti stringesitus meetodi parameetrite jaoks

Skeleton API

Serveripoolne API skelett koosneb mitmest baasklassist:
index.php - Apache'i kataloogi indeksfail, mis sisaldab kõiki API-kutseid, parsib parameetreid ja kutsub API meetodeid
MySQLiWorker – üks klass MySQLi andmebaasiga töötamiseks MySQLi kaudu
apiBaseCalss.php on süsteemi kõigi API-de vanemklass – iga API peab korrektseks töötamiseks pärima sellest klassist
apiEngine.php - süsteemi põhiklass - analüüsib läbitud parameetreid (pärast nende eelparsimist failis index.php), ühendab vajaliku api-klassi (meetodi request_once kaudu), kutsub selles vajaliku meetodi ja tagastab tulemuse JSON-is vormingus
apiConstants.php - klass konstantidega api kõnede ja vigade edastamise jaoks
apitest.php – test api uute meetodite testimiseks enne nende lisamist tootmisversiooni

Kogu mehhanism näeb välja selline:
Teeme serverile päringu – näiteks www.example.com/api/?apitest.helloWorld= ()
Serveri poolel analüüsib fail index.php läbitud parameetreid. Index.php võtab alati ainult esimese elemendi edastatud $_REQUEST parameetrite loendist – see tähendab, et selline konstruktsioon nagu www.example.com/api/?apitest.helloWorld= ()&apitest.helloWorld2 – kutsub sisse ainult meetodi helloWorld apitest. HelloWorld2 meetodit ei kutsuta

Nüüd lisateavet igaühe kohta

Üritasin faile piisavalt dokumenteerida, et mitte teksti jaoks palju ruumi võtta. Nendes failides, kus kommentaare pole, annan siiski kirjelduse.

Indeks.php

Nagu ma varem ütlesin, on see Apache'i sisendindeksi fail, mis tähendab, et see võtab vastu kõik kõned, näiteks www.example.com/api.

0)( nõuda_once "apiEngine.php"; foreach ($_REQUEST kui $apiFunctionName => $apiFunctionParams) ( $APIEngine=new APIEngine($apiFunctionName,$apiFunctionParams); kaja $APIEngine->callApiFunction ();callApiFunction) ( $jsonError->error="Ühtegi funktsiooni pole kutsutud"; kaja json_encode($jsonError); ) ?>

Kõigepealt määrame sisutüübi - text/html (siis saate seda meetodites ise muuta) ja kodeeringu - UTF-8.
Järgmisena kontrollime, kas nad küsivad meilt midagi. Kui ei, siis väljastame veaga JSON-i.
Kui päringu parameetreid on, siis ühendame API mootori faili - apiEngine.php ja loome läbitud parameetritega mootoriklassi ning helistame api meetodile.
Väljume tsüklist, kuna otsustasime, et töötleme ainult ühte kõnet.

apiEngine.php

Tähtsuselt teine ​​klass on apiEngine klass – see on mootor api ja nende meetodite kutsumiseks.
apiFunctionParams = stripcslashes($apiFunctionParams); //Parsitakse kahest elemendist koosnev massiiv - API nimi, - API-s oleva meetodi nimi $this->apiFunctionName = explode("_", $apiFunctionName); ) //JSON-vastuse funktsiooni loomine createDefaultJson() ( $retObject = json_decode("()"); $response = APIConstants::$RESPONSE; $retObject->$response = json_decode("()"); return $retObject ; ) register if (file_exists($apiName . ".php")) ( $apiClass = APIEngine::getApiEngineByName($apiName); // Hankige API-objekt $apiReflection = new ReflectionClass($apiName); // Peegelduse kaudu saame teavet klassi try objekti kohta ( $functionName = $this->apiFunctionName;//Meetodi nimi $apiReflection->getMethod($functionName);//Kontrollige meetodi olemasolu $response = APIConstants: :$RESPONSE $jsonParams = json_decode($this- >apiFunctionParams);//Dekodeerige päringu parameetrid JSON-objektiks if ($jsonParams) ( if (isset($jsonParams->responseBinary))(//Et oleks võimalik tagastada mitte JSON, vaid binaarandmed, nagu zip, png ja muu sisu, tagastavad $apiClass->$functionName($jsonParams);//Meetodi kutsumine API-s )else( $resultFunctionCall->$response = $apiClass->$functionName ($jsonParams);//Kutsuge API-s meetod, mis tagastab JSON-objekti) ) else ( //Kui JSON-i päringu parameetrite dekodeerimisel ilmneb tõrge $resultFunctionCall->errno = APIConstants::$ERROR_ENGINE_PARAMS; $resultFunctionCall->error = "Antud parameetrite viga"; ) ) püüdmine (Erand $ex) ( //Ootamatu erand $resultFunctionCall->error = $ex->getMessage(); ) ) else ( //Kui taotletud API-t ei leita $resultFunctionCall->errno = APIConstants::$ ERROR_ENGINE_PARAMS; $resultFunctionCall->error = "Faili ei leitud" $resultFunctionCall->REQUEST = $_REQUEST ) return json_encode($resultFunctionCall); ) ) ?>

apiConstants.php

Seda klassi kasutatakse ainult konstantide salvestamiseks.

MySQLiWorker.php

Üks klass andmebaasiga töötamiseks. Muidu on see tavaline üksildane - selliseid näiteid on Internetis palju.

dbName = $dbName; ise::$instance->dbHost = $dbHost; ise::$instance->dbUser = $dbUser; self::$instance-> dbPassword = $dbPassword; ise::$instance->openConnection(); ) return self::$instance; ) //Määrake andmebaasi päringuparameetrite tüübid ja tagastage string sidumiseks funktsiooni ->bind kaudu readyParams($params) ( $retSTMTString = ""; foreach ($params kui $väärtus) ( if (is_int( $väärtus) ||. is_double ($väärtus)) ( $retSTMTString.="d"; ) if (on_string($value)) ( $retSTMTString.="s"; ) ) return $retSTMTString ) //Ühenda andmebaasi avalik funktsioon openConnection() ( if (is_null($this->connectLink)) ( $this->connectLink = new mysqli($this->dbHost, $this->dbUser, $this->dbPassword, $this-> dbNimi null; else ( mysqli_report(MYSQLI_REPORT_ERROR ); ) ) return $this->connectLink ) //Sule ühendus andmebaasiga avaliku funktsiooniga closeConnection() ( if (!is_null($this->connectLink) >connectLink->close() ) //Teendab vastuse assotsiatiivseks massiiviks avalikuks funktsiooniks stmt_bind_assoc(&$stmt, &$out) ( $data = mysqli_stmt_result_metadata($stmt); $väljad = array(); $out = array(); $väljad = $stmt; $loendus = 1; $currentTable = ""; while ($field = mysqli_fetch_field($data)) ( if (strlen($currentTable) == 0) ( $currentTable = $field->table; ) $fields[$count] = &$out[$field->name ]; $count++ ) call_user_func_array("mysqli_stmt_bind_result", $väljad); ) ) ?>

apiBaseClass.php

Noh, jõuame süsteemi ühe kõige olulisema klassini - kõigi süsteemi API-de baasklassini.

mySQLWorker = MySQLiWorker::getInstance($dbName,$dbHost,$dbKasutaja,$dbParool); ) ) function __destruct() ( if (isset($this->mySQLWorker))( //Kui andmebaasiga ühendus loodi, $this->mySQLWorker->closeConnection(); //siis sulgege see, kui meie klass on pole enam vaja ) ) //Looge vastuste jaoks vaike-JSON-i funktsiooni createDefaultJson() ( $retObject = json_decode("()"); return $retObject; ) //Täitke JSON-objekt MySQLiWorkeri funktsiooni vastusega fillJSON(&$ jsonObject, &$stmt, &$mySQLWorker) ( $row = array(); $mySQLWorker->stmt_bind_assoc($stmt, $row); while ($stmt->fetch()) ( foreach ($row as $key = > $väärtus) ($ võti = strtolower($key); $jsonObject->$key = $väärtus; katkestus; tagastab $jsonObject;

Nagu näete, sisaldab see klass mitmeid "utiliidi" meetodeid, näiteks:
konstruktor, milles andmebaasiga ühendus luuakse, kui praegune API hakkab andmebaasiga töötama;
hävitaja - jälgib ressursside vabastamist - andmebaasiga loodud ühenduse katkestamine
createDefaultJson – loob meetodi vastuse jaoks vaike-JSON-i
fillJSON - kui eeldatakse, et päring tagastab ainult ühe kirje, täidab see meetod vastuse JSON-i andmebaasi vastuse esimese rea andmetega

Loome oma API

See on tegelikult kogu selle API selgroog. Nüüd vaatame, kuidas seda kõike kasutada, kasutades näidet esimese API nimega apitest loomisest. Ja kirjutame sellesse paar lihtsat funktsiooni:
üks ilma parameetriteta
üks parameetritega ja ta tagastab need meile, et oleks selge, et ta on need läbi lugenud
üks, mis tagastab meile binaarandmed

Ja nii loome järgmise sisuga klassi apitest.php

looDefaultJson(); $retJSON->withoutParams = "Seda meetodit kutsutakse ilma parameetriteta"; tagasta $retJSON; ) //http://www.example.com/api/?apitest.helloAPIWithParams=("TestParamOne":"Esimese tekst parameeter") function helloAPIWithParams($apiMethodParams) ( $retJSON = $this->createDefaultJson(); if (isset($apiMethodParams->TestParamOne))( //Kõik on korras, parameetrid on õiged, tagastame need $retJSON ->retParameter=$ apiMethodParams->TestParamOne )else( $retJSON->errorno= APIConstants::$ERROR_PARAMS; ) return $retJSON ) //http://www.example.com/api/?apitest.helloAPIResponse; ("responseBinary": 1) funktsioon helloAPIResponseBinary($apiMethodParams)( header("Content-type: image/png"); kaja file_get_contents("http://habrahabr.ru/i/error-404-monster.jpg") ;) ) ?>

Testimismeetodite mugavuse huvides lisan neile aadressi, kuhu saan teha kiire testimissoovi.

Ja nii on meil kolm meetodit

Funktsioon helloAPI() ( $retJSON = $this->createDefaultJson(); $retJSON->withoutParams = "Seda meetodit kutsutakse ilma parameetriteta"; tagasta $retJSON; )

See on lihtne meetod, millel pole parameetreid. Selle GET-kõne aadress on www.example.com/api/?apitest.helloAPI= ()

Täitmise tulemuseks on selline leht (brauseris)

See meetod võtab parameetreid. TestParamOne on nõutav ja me kontrollime seda. Seda ei saa edastada, JSON tagastatakse veaga

Funktsioon helloAPIWithParams($apiMethodParams) ( $retJSON = $this->createDefaultJson(); if (isset($apiMethodParams->TestParamOne))( //Kõik on korras, parameetrid on õiged, tagastame need $retJSON->retParameter =$apiMethodParams-> TestParamOne )else( $retJSON->errorno= APIConstants::$ERROR_PARAMS; ) return $retJSON;
Täitmise tulemus

helloAPIResponseBinary

Ja viimane meetod helloAPIResponseBinary - tagastab binaarandmed - pildi habrist olematu lehe kohta (näitena)
funktsioon helloAPIResponseBinary($apiMethodParams)( header("Sisutüüp: pilt/jpeg"); echo file_get_contents("http://habrahabr.ru/i/error-404-monster.jpg"); )
Nagu näete, on pealkiri graafilise sisu kuvamiseks asendatud.
Tulemus saab olema selline

Mitte kaua aega tagasi esitas üks mu külastaja mulle selle kohta küsimuse e-mail: "". Otsustasin, et see oleks teistele kasutajatele väga kasulik, eriti kuna vaatamata protsessi näilisele keerukusele on kõik väga-väga lihtne. Peate lihtsalt omama kõige elementaarsemaid teadmisi PHP.

Kui te äkki ei saa aru, millest me räägime, lugege kõigepealt artiklit:. Lase käia. Vaatame, milliste saitide jaoks neid vaja on? API:

Esimene asi, mida peate mõistma, on see API Mitte iga sait ei vaja seda (isegi kui see kuulub ühte ülaltoodud rühmadest).

Kui sa nii arvad API on teie veebisaidil vajalik, siis vaatame selle loomise näidet. Olgu meil järgmine ülesanne: on olemas EPS (nagu näiteks WebMoney). Ja me tahame, et kasutaja saaks oma koodi abil meie koodi kasutada API, saate teada oma kontojäägi.

Loome faili (näiteks api.php), mille me saame HANGI taotlusi kasutajatelt mitmesuguse teabe saamiseks. Kirjutame sellesse töötlejasse järgmise koodi:

if ($_GET["action"] == "getbalance") (
$saldo;
//Uuri andmebaasist kontojääk ja kirjuta see saldomuutujasse
kaja $tasakaal;
}
?>

Nüüd arendajad API peaks andma kasutajatele teavet päringu esitamise kohta, et kasutaja saaks teada oma kontojäägi:

Http://mysite.ru/api.php?action=getbalance&key=fa9sgwlgjs9gdsjlgjdsjglsdlgs

Kasutajad moodustavad selle päringu oma skriptides (näiteks kaudu cURL). Parameeter võti on iga kasutaja jaoks ainulaadne võti. Ja vastus sellele päringule on number, mis vastutab kasutaja saldo eest. Kõik muud võimalused luuakse samamoodi. API. Saate lisada mitmesuguseid muid parameetreid: näiteks hankida konto täiendamise tehingute loend ühest kuupäevast teise. Soovitatav on tagastada loendid ise vormingus JSON.

Seitse kitse ja hunt ilma silmata

RESTful API loomine PHP-s

REST või täisvormis, Esinduslik riigiülekanne on muutunud standardseks disainiarhitektuuriks veebi API arendamiseks.

REST on väga lihtne teabehaldusliides ilma täiendavate taustakihtideta. Iga teabetükk on ainulaadselt identifitseeritud globaalse identifikaatoriga, näiteks URL-iga. Igal URL-il on omakorda rangelt määratletud vorming.

REST kasutab HTTP päringu meetodeid, et end olemasolevasse HTTP arhitektuuri lisada. Need toimingud on järgmised:

GET – kasutatakse põhiliste lugemispäringute jaoks serverile

PUT – kasutatakse serveris olemasoleva objekti muutmiseks

POST – kasutatakse serveris uue objekti loomiseks

DELETE – kasutatakse objekti kustutamiseks serveris

Ja nüüd asja juurde, st. lihtsa API kirjutamine, mida saate oma projektides kasutada.

Mis on API

Laiemas mõttes on API veebirakenduse liides, mis võimaldab meetoditele avalikult juurde pääseda ja neid väljastpoolt juhtida. API-t kasutatakse tavaliselt siis, kui teil on vaja hankida rakendusest andmeid (näiteks artiklit või muid andmeid) ressurssi (näiteks veebisaiti) tegelikult külastamata. Selle võimaldamiseks on rakenduse jaoks rakendatud API, mis võimaldab kolmandate osapoolte rakendustel teha taotlusi ja tagastada määratud andmed kasutajale väliselt. Veebis tehakse seda sageli RESTfuli abil.

Näidisartikli taotluses võib API sisaldada URI-d:

example.com/api/v1/retsept/artikkel

Kui saadate sellele URL-ile GET-päringu, võib vastuseks olla viimaste uudiste loend, PUT-päring võib uudise andmebaasi lisada.

Kui taotlete /artikkel /141, on see kindel uudis. Need näited näitavad, kuidas rakendusega suhelda.

Oma API loomine

Loome .htaccess-faili, et teisendada GET-päringud kontrollerile arusaadavateks parameetriteks.

RewriteEngine on RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule api/v1/(.*)$ api/v1/api.php?request=$1

Mida tähendavad selles failis olevad read?

Esimene rida kontrollib ümberkirjutamismooduli olemasolu. Kui see töötab, käivitatakse järgmised read.

Järgmisena teatatakse URL-ide uuesti määratlemise võimalusest. See tähendab, et api/v1/ tee suunatakse ümber aadressile api/v1/index.php. Sümbolid (.*) tähistavad muutujaid, mida tuleb töödelda ja $ on eraldaja, mille järel algab järgmine loogika. Samuti - tähendab tõstutundlikku - et muutujad lisatakse uuele URL-ile, L - mod_rewrite ei töötle enam midagi peale määratud.

Deklareerime klassi, omadused ja konstruktori.

abstraktse klassi API ( /** * Atribuut: meetod * GET, POST, PUT, DELETE */ kaitstud $method = ""; /** * Atribuut: lõpp-punkt * URI-s nõutav mudel. nt: /failid */ kaitstud $endpoint = ""; /** * Omadus: verb * Lõpp-punkti valikuline lisadeskriptor, mida kasutatakse asjade jaoks, mida ei saa põhimeetoditega käsitleda, nt: /failid/protsess */ kaitstud $verb = "" /** * Atribuut: args * Kõik täiendavad URI komponendid pärast lõpp-punkti ja tegusõna on eemaldatud, meie * puhul ressursi täisarvuline ID, nt. ///* või / /*/ kaitstud $args = Array(); /** * Omadus: fail * Salvestab PUT-päringu sisendi */ kaitstud $fail = Null; /** * Konstruktor: __construct * Luba CORS-i jaoks, koosta ja eeltöötle andmeid */ public function __construct($request) ( header("Access-Control-Allow-Orgin: *"); header("Access-Control -Allow-Methods: *"); header("Sisu tüüp: rakendus/json"); $this->args = explode("/", rtrim($request, "/")); $this->endpoint = massiivi_nihe($this->args) if (massiivi_võti_exists(0, $this->args) && !on_numeric($this->args)) ( $this->verb = array_shift($this->args); ) $this->method = $_SERVER["REQUEST_METHOD"]; if ($this->method == "POST" && array_key_exists("HTTP_X_HTTP_METHOD", $_SERVER)) (if ($_SERVER["HTTP_X_HTTP_METHOD"]; DELETE") ( $this->method = "DELETE"; ) else if ($_SERVER["HTTP_X_HTTP_METHOD"] == "PAN") ( $this->method = "PUT"; ) else ( viska uus Erand(" Ootamatu päis"); ) ) switch ($this->method) ( tõuke "DELETE": suurtäht "POST": $this->request = $this->_cleanInputs($_POST); katkestus; suurtäht "GET": $ this->request = $this->_cleanInputs($_GET break; case "PUT"): $this->request = $this->_cleanInputs($_GET); $see->fail = file_get_contents("php://input"); murda; vaikimisi: $this->_response("Vigane meetod", 405); murda; ) ) public function processAPI() ( if (method_exists($this, $this->endpoint)) ( return $this->_response($this->($this->endpoint)($this->args)); ) return $this->_response("Ei lõpp-punkti: $this->endpoint", 404 ) privaatfunktsioon _response($data, $status = 200) ( header("HTTP/1.1 " . $status . " " ). $this->_requestStatus($status)); return json_encode($data) privaatfunktsioon _cleanInputs($data) ( $clean_input = Array(); if (is_array($data)) ( foreach ($andmed kui $k); => $v) ( $puhas_sisend[$k] = $this->_cleanInputs($v); ) ) else ( $clean_input = trim(riba_sildid($andmed)); ) return $clean_input ) privaatfunktsioon _requestStatus($ kood) ( $status = array(200 => "OK", 404 => "Ei leitud", 405 => "Meetod pole lubatud", 500 => "Sisemine serveri viga",); return ($status[$kood ])?$olek[$kood]:$olek ) )

Selle abstraktse klassi deklareerimisega takistasime PHP-l selle klassi konkreetset eksemplari looma. Sealt saame meetodeid kasutada ainult teises klassis pärimise teel. Kaitstud meetodile pääseb juurde ainult klassis endas ja selle järglastes.

API klassi loomine

Loome MyAPI klassi, mis pärib abstraktse API klassi.

nõuda_once "API.klass.php"; klass MyAPI laiendab API-t ( kaitstud $Kasutaja; avalik funktsioon __construct($request, $origin) ( ema::__construct($request); // Abstraheeritud näiteks $APIKey = new Models\APIKey(); $User = uued mudelid \User(); if (!array_key_exists("apiKey", $this->request)) ( viska uus erand("API võtit pole esitatud"); ) else if (!$APIKey->verifyKey($this->request) ["apiKey"], $origin)) ( viska uus erand("Invalid API Key"); ) else if (array_key_exists("token", $this->request) && !$User->get("token", $this->request["token"])) ( viska uus erand("Invalid User Token"); ) $this->User = $Kasutaja) /** * Lõpp-punkti näide */ kaitstud funktsiooni näide() ( if ($this->method == "GET") ( return "Teie nimi on " . $this->User->name; ) else ( return "Aktsepteerib ainult GET-i taotlusi"; ) )

API kasutamine

// Sama serveri päringutel ei ole HTTP_ORIGIN päist, kui (!array_key_exists("HTTP_ORIGIN", $_SERVER)) ( $_SERVER["HTTP_ORIGIN"] = $_SERVER["SERVER_NAME"]; ) proovi ( $API = new MyAPI($_REQUEST["päring"], $_SERVER["HTTP_ORIGIN"] echo $API->processAPI(Erand $e) ( echo json_encode(Array("error" => $e- >); getMessage()));

Selle kohmakas tõlge: http://coreymaynard.com/blog/creating-a-restful-api-with-php/

PHP pakub MySQL-iga ühenduse loomiseks kolme erinevat API-d. Allpool näitame laienduste mysql, mysqli ja PDO pakutavaid API-sid. Iga koodilõik loob ühenduse saidil "example.com" töötava MySQL-serveriga, kasutades kasutajanime "user" ja parooli "password". Ja kasutaja tervitamiseks käivitatakse päring.

Näide nr 1 Kolme MySQL API võrdlemine

//mysqli
$mysqli = uus mysqli ("example.com" , "user" , "password" , "database" );
$result = $mysqli -> query();
$rida = $tulemus -> too_assoc();

//KPN
$pdo = uus KPN ( "mysql:host=example.com;dbname=andmebaas", "kasutaja" , "parool" );
$lause = $pdo -> päring ( "VALI "Tere, kallis MySQL-i kasutaja!" AS _message FROM DUAL");
$rida = $lause -> too (PDO::FETCH_ASSOC);
echo htmlentities($rida["_sõnum"]);

//mysql
$c = mysql_connect("example.com" , "kasutaja" , "parool" );
mysql_select_db("andmebaas");
$result = mysql_query ( "VALI "Tere, kallis MySQL-i kasutaja!" AS _message FROM DUAL");
$rida = mysql_fetch_assoc ($tulemus);
echo htmlentities($rida["_sõnum"]);
?>

Soovitatav API

Soovitatav on kasutada laiendusi mysqli või PDO_MySQL. Uue arenduse jaoks ei ole soovitatav kasutada vana mysql-i laiendust, kuna see oli PHP 5.5.0-s aegunud ja PHP 7-s eemaldati. Allpool on toodud üksikasjalik funktsioonide võrdlusmaatriks. Kõigi kolme laienduse üldist jõudlust peetakse ligikaudu samaks. Kuigi laienduse jõudlus annab vaid murdosa PHP veebipäringu kogu tööajast. Sageli on mõju nii väike kui 0,1%.

Funktsioonide võrdlus

Minult küsitakse sageli kuidas API-ga töötada. Kõige populaarsem probleem, mis on seotud API, on - töötades VKontakte API-ga. Selles artiklis ma näitan kuidas töötada VKontakte API-ga, ja mis kõige tähtsam, ma näitan teile seda kõik API-d töötavad samal põhimõttel.

Siin menetlust mida peate selleks tegema alustage töötamist mis tahes API-ga:

1. Otsi dokumentatsioon nagu vajatud API.
2. Vaata API-ühenduse näited. Siin võib olla erinevaid võimalusi. Näiteks ühe teenuse jaoks on vaja pärast registreerimist väljastada salajane võti. Teise teenuse puhul ei nõua kõik päringud salajasi võtmeid. Kolmandas teenuses on valikud salajase võtmega ja ilma töötamiseks. Mõnikord kutsutakse salajast võtit märk.
3. Kopeeri lihtne valmiskood dokumentatsiooni saidilt ja kontrollige selle toimimist. Kui see ei tööta, otsige viga ise, kuna teenusel seda tõenäoliselt pole.
4. Otsi dokumentatsioonis meetod, mis lahendab teie probleemi.
5. Kasutades näiteid ja meetodi kirjeldust, saatke API-le õige päring.
6. Olenevalt vastuse vormingust sõeluge see alla " komponendid", ja tehke siis seda, mida vaja – kuvage see kasutajale, salvestage faili, saatke andmebaasi jms.

Ja näitena nende juhiste järgimisest vaatleme VKontakte API. Niisiis:

1. Link aadressile dokumentatsioon.
2. Sel juhul on meetodeid, mis on avalikud ja seetõttu ei vaja tokenit, ja on meetodeid, mis seda nõuavad.
3. Antud juhul ei leidnud ma ühtegi näidet konkreetses keeles. Võib-olla on nad seal, kuid ilmselgelt pole neid silmapiiril. Tavaliselt, kl API Iga meetodi kohta on erinevates keeltes näited.
4. Me tahame taganeda 5 viimast postitust konkreetse kasutaja seinalt ja seejärel kuvage need oma veebisaidil. Meetod, mida vajame.

Nüüd peame saatke API-le päring kasutades meetodi kirjeldust. Teeme seda läbi PHP:

$wall = file_get_contents("https://api.vk.com/method/wall.get?v=5.3&filter=others&domain=myrusakov&count=5");
print_r($sein);
?>

Sel juhul kasutan API 5.3 (v=5,3), kuvan kõik kirjed olenemata autorist ( filter=teised) teie lehelt ( domeen=myrusakov) koguses 5 asjad ( arv = 5). Ma arvan, et siin on kõik väga läbipaistev.

Saime vastuse vormingus JSON, ja nüüd peame liikuma viimase punkti juurde – analüüsima vastust küsimusele " komponendid". Järgmisena kuvame seinalt postitused enam-vähem loetaval kujul oma kodulehe lehel. Saadud PHP kood:

$wall = file_get_contents("http://api.vk.com/method/wall.get?v=5.3&filter=others&domain=myrusakov&count=5"); // Saada päring
$sein = json_decode($sein); // Teisendage JSON-string massiiviks
$sein = $sein->vastus->üksused; // Hankige hulgaliselt kommentaare
jaoks ($i = 0; $i< count($wall); $i++) {
kaja"

".($i + 1).". ".$wall[$i]->tekst."
".date("Y-m-d H:i:s", $wall[$i]->date)."

Nagu näete, on kõik väga lihtne. Kõige raskem on selle tükeldamine koostisosadeks. Eelistan tulemust väljastada API läbi print_r ja alles siis kirjutage selle töötlemine. Kuigi võite vaadata meetodi kirjelduses olevat vastuse näidet ja seejärel kirjutada parser.