setup - Chiama un'API REST in PHP




setup php rest api (8)

Il nostro cliente mi ha fornito una API REST a cui devo fare una chiamata PHP. Ma in realtà la documentazione fornita con l'API è molto limitata, quindi non so davvero come chiamare il servizio.

Ho provato a Google, ma l'unica cosa che è venuta fuori era un Yahoo! già scaduto! tutorial su come chiamare il servizio. Non menzionare le intestazioni o qualsiasi informazione approfondita.

C'è qualche informazione decente su come chiamare un'API REST o qualche documentazione a riguardo? Perché anche su W3schools, descrivono solo il metodo SOAP. Quali sono le diverse opzioni per creare API di riposo in PHP?



@Christoph Winkler ha detto che questa è una classe base per raggiungerla:

curl_helper.php

// This class has all the necessary code for making API calls thru curl library

class CurlHelper {

// This method will perform an action/method thru HTTP/API calls
// Parameter description:
// Method= POST, PUT, GET etc
// Data= array("param" => "value") ==> index.php?param=value
public static function perform_http_request($method, $url, $data = false)
{
    $curl = curl_init();

    switch ($method)
    {
        case "POST":
            curl_setopt($curl, CURLOPT_POST, 1);

            if ($data)
                curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
            break;
        case "PUT":
            curl_setopt($curl, CURLOPT_PUT, 1);
            break;
        default:
            if ($data)
                $url = sprintf("%s?%s", $url, http_build_query($data));
    }

    // Optional Authentication:
    //curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
    //curl_setopt($curl, CURLOPT_USERPWD, "username:password");

    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);

    $result = curl_exec($curl);

    curl_close($curl);

    return $result;
}

}

Quindi puoi sempre includere il file e usarlo ad esempio: any.php

    require_once("curl_helper.php");
    ...
    $action = "GET";
    $url = "api.server.com/model"
    echo "Trying to reach ...";
    echo $url;
    $parameters = array("param" => "value");
    $result = CurlHelper::perform_http_request($action, $url, $parameters);
    echo print_r($result)

Ci sono molti clienti in realtà. Uno di questi è Pest : controlla questo. E ricorda che queste chiamate REST sono semplici richieste http con vari metodi: GET, POST, PUT e DELETE.


Dovrai sapere se l'API REST che stai chiamando supporta GET o POST o entrambi i metodi. Il codice seguente è qualcosa che funziona per me, sto chiamando la mia API del servizio web, quindi so già cosa prende l'API e cosa restituirà. Supporta entrambi i metodi GET e POST, quindi le informazioni meno sensibili vengono inserite nell'URL (GET) e le informazioni come nome utente e password vengono inviate come variabili POST. Inoltre, tutto va oltre la connessione HTTPS.

All'interno del codice API, codifico un array che voglio ritornare in formato json, quindi semplicemente uso il comando PHP echo $ my_json_variable per rendere disponibile quella stringa json al client.

Quindi, come potete vedere, la mia API restituisce i dati json, ma è necessario conoscere (o esaminare i dati restituiti per scoprire) in che formato è la risposta dall'API.

Questo è il modo in cui mi collego all'API dal lato client:

$processed = FALSE;
$ERROR_MESSAGE = '';

// ************* Call API:
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://www.myapi.com/api.php?format=json&action=subscribe&email=" . $email_to_subscribe);
curl_setopt($ch, CURLOPT_POST, 1);// set post data to true
curl_setopt($ch, CURLOPT_POSTFIELDS,"username=myname&password=mypass");   // post data
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
curl_close ($ch);

// returned json string will look like this: {"code":1,"data":"OK"}
// "code" may contain an error code and "data" may contain error string instead of "OK"
$obj = json_decode($json);

if ($obj->{'code'} == '1')
{
  $processed = TRUE;
}else{
  $ERROR_MESSAGE = $obj->{'data'};
}

...

if (!$processed && $ERROR_MESSAGE != '') {
    echo $ERROR_MESSAGE;
}

A proposito, ho anche provato ad usare il metodo file_get_contents () come suggerito da alcuni utenti qui, ma non mi va bene. Ho scoperto il metodo del ricciolo per essere più veloce e più affidabile.


Se sei libero di utilizzare strumenti di terze parti, dai un'occhiata a questo: https://github.com/CircleOfNice/DoctrineRestDriver

Questo è un modo completamente nuovo di lavorare con le API.

Prima di tutto si definisce un'entità che definisce la struttura dei dati in arrivo e in uscita e la annota con origini dati:

/*
 * @Entity
 * @DataSource\Select("http://www.myApi.com/products/{id}")
 * @DataSource\Insert("http://www.myApi.com/products")
 * @DataSource\Select("http://www.myApi.com/products/update/{id}")
 * @DataSource\Fetch("http://www.myApi.com/products")
 * @DataSource\Delete("http://www.myApi.com/products/delete/{id}")
 */
class Product {
    private $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

Ora è abbastanza semplice comunicare con l'API REST:

$product = new Product();
$product->setName('test');
// sends an API request POST http://www.myApi.com/products ...
$em->persist($product);
$em->flush();

$product->setName('newName');
// sends an API request UPDATE http://www.myApi.com/products/update/1 ...
$em->flush();

Se si utilizza Symfony, esiste un ottimo bundle client di resto che include anche tutte le ~ 100 eccezioni e le lancia invece di restituire un codice di errore + un messaggio privi di significato.

Dovresti davvero controllarlo: https://github.com/CircleOfNice/CiRestClientBundle

Adoro l'interfaccia:

try {
    $restClient = new RestClient();
    $response   = $restClient->get('http://www.someUrl.com');
    $statusCode = $response->getStatusCode();
    $content    = $response->getContent();
} catch(OperationTimedOutException $e) {
    // do something
}

Funziona con tutti i metodi http.


Usa HTTPFUL

Httpful è una libreria PHP semplice, concatenabile e leggibile destinata a rendere sane le parole HTTP. Permette allo sviluppatore di concentrarsi sull'interazione con le API invece di passare al setaccio le pagine set_opt di curl ed è un client REST PHP ideale.

Httpful include ...

  • Supporto del metodo HTTP leggibile (GET, PUT, POST, DELETE, HEAD e OPTIONS)
  • Intestazioni personalizzate
  • Analisi automatica "intelligente"
  • Serializzazione automatica del carico utile
  • Autentica di base
  • Autenticazione lato cliente
  • Richiedi "Modelli"

Ex.

Invia una richiesta GET. Ottieni automaticamente la risposta JSON analizzata.

La libreria rileva il tipo di contenuto JSON nella risposta e analizza automaticamente la risposta in un oggetto PHP nativo.

$uri = "https://www.googleapis.com/freebase/v1/mqlread?query=%7B%22type%22:%22/music/artist%22%2C%22name%22:%22The%20Dead%20Weather%22%2C%22album%22:%5B%5D%7D";
$response = \Httpful\Request::get($uri)->send();

echo 'The Dead Weather has ' . count($response->body->result->album) . " albums.\n";

È possibile accedere a qualsiasi API REST con estensione cURL PHP. Tuttavia, la documentazione API (metodi, parametri, ecc.) Deve essere fornita dal cliente!

Esempio:

// Method: POST, PUT, GET etc
// Data: array("param" => "value") ==> index.php?param=value

function CallAPI($method, $url, $data = false)
{
    $curl = curl_init();

    switch ($method)
    {
        case "POST":
            curl_setopt($curl, CURLOPT_POST, 1);

            if ($data)
                curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
            break;
        case "PUT":
            curl_setopt($curl, CURLOPT_PUT, 1);
            break;
        default:
            if ($data)
                $url = sprintf("%s?%s", $url, http_build_query($data));
    }

    // Optional Authentication:
    curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
    curl_setopt($curl, CURLOPT_USERPWD, "username:password");

    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);

    $result = curl_exec($curl);

    curl_close($curl);

    return $result;
}




rest