Appeler une API REST en PHP

Notre client m'avait donné une API REST à laquelle je dois appeler PHP. Mais en fait, la documentation fournie avec l'API est très limitée, donc je ne sais pas vraiment comment appeler le service.

J'ai essayé de Google, mais la seule chose qui est apparue était un Yahoo! déjà expiré tutoriel sur la façon d'appeler le service. Sans mentionner les en-têtes ou quoi que ce soit dans les informations détaillées.

Existe-t-il des informations décentes sur la façon d'appeler une API REST ou une documentation à ce sujet? Parce que même sur W3schools, ils ne décrivent que la méthode SOAP. Quelles sont les différentes options pour créer une API de repos en PHP?

Vous pouvez accéder à n'importe quelle API REST avec l' cURLextension PHP . Cependant, la documentation de l'API (méthodes, paramètres, etc.) doit être fournie par votre client!

Exemple:

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

Si vous avez une URL et que votre php la prend en charge, vous pouvez simplement appeler file_get_contents:

$response = file_get_contents('http://example.com/path/to/api/call?param1=5');

si $ response est JSON, utilisez json_decode pour le transformer en tableau php:

$response = json_decode($response);

si $ response est XML, utilisez la classe simple_xml:

$response = new SimpleXMLElement($response);

http://sg2.php.net/manual/en/simplexml.examples-basic.php

Utilisez Guzzle . Il s'agit d'un "client PHP PHP qui facilite le travail avec HTTP / 1.1 et évite la consommation de services Web". Travailler avec Guzzle est beaucoup plus facile que de travailler avec cURL.

Voici un exemple tiré du site Web:

$client = new GuzzleHttp\Client();
$res = $client->get('https://api.github.com/user', [
    'auth' =>  ['user', 'pass']
]);
echo $res->getStatusCode();           // 200
echo $res->getHeader('content-type'); // 'application/json; charset=utf8'
echo $res->getBody();                 // {"type":"User"...'
var_export($res->json());             // Outputs the JSON decoded data

CURL est la façon la plus simple de procéder. Voici un simple appel

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "THE URL TO THE SERVICE");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, POST DATA);
$result = curl_exec($ch);


print_r($result);
curl_close($ch);

Utilisez HTTPFUL

Httpful est une bibliothèque PHP simple, chaînable et lisible destinée à rendre le langage HTTP sain d'esprit. Il permet au développeur de se concentrer sur l'interaction avec les API au lieu de parcourir les pages curl set_opt et est un client PHP REST idéal.

Httpful comprend ...

• Prise en charge des méthodes HTTP lisibles (GET, PUT, POST, DELETE, HEAD et OPTIONS)
• En-têtes personnalisés
• Analyse automatique "intelligente"
• Sérialisation automatique de la charge utile
• Authentification de base
• Authentification du certificat côté client
• Demander des "modèles"

Ex.

Envoyez une demande GET. Obtenez une réponse JSON automatiquement analysée.

La bibliothèque remarque le type de contenu JSON dans la réponse et analyse automatiquement la réponse dans un objet PHP natif.

$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";

Vous aurez besoin de savoir si l'API REST que vous appelez des supports GETou POST, ou les deux méthodes. Le code ci-dessous est quelque chose qui fonctionne pour moi, j'appelle ma propre API de service Web, donc je sais déjà ce que l'API prend et ce qu'elle renverra. Il prend en charge les méthodes GETet POST, de sorte que les informations moins sensibles entrent dans le URL (GET), et les informations telles que le nom d'utilisateur et le mot de passe sont soumises en tant que POSTvariables. De plus, tout passe par la HTTPSconnexion.

Dans le code API, j'encode un tableau que je veux retourner au format json, puis j'utilise simplement la commande PHP echo $my_json_variablepour rendre cette chaîne json disponible pour le client.

Donc, comme vous pouvez le voir, mon API renvoie des données json, mais vous devez savoir (ou regarder les données renvoyées pour savoir) dans quel format est la réponse de l'API.

Voici comment je me connecte à l'API du côté 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;
}

BTW, j'ai également essayé d'utiliser la file_get_contents()méthode comme certains des utilisateurs ici l'ont suggéré, mais cela ne fonctionne pas bien pour moi. J'ai découvert que la curlméthode était plus rapide et plus fiable.

Il y a en fait beaucoup de clients. L'un d'eux est Pest - vérifiez cela. Et gardez à l'esprit que ces appels REST sont de simples requêtes http avec différentes méthodes: GET, POST, PUT et DELETE.

Vous pouvez utiliser file_get_contentspour émettre n'importe quelle POST/PUT/DELETE/OPTIONS/HEADméthode http , en plus de la GETméthode comme le suggère le nom de la fonction.

Comment publier des données en PHP en utilisant file_get_contents?

Si vous utilisez Symfony, il existe un excellent ensemble de clients de repos qui comprend même toutes les ~ 100 exceptions et les jette au lieu de renvoyer un code d'erreur + un message sans signification.

Vous devriez vraiment le vérifier: https://github.com/CircleOfNice/CiRestClientBundle

J'adore l'interface:

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

Fonctionne pour toutes les méthodes http.

comme @Christoph Winkler l'a mentionné, il s'agit d'une classe de base pour y parvenir:

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

}

Ensuite, vous pouvez toujours inclure le fichier et l'utiliser, par exemple: 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)

Si vous êtes ouvert à l'utilisation d'outils tiers, vous devriez jeter un œil à celui-ci: https://github.com/CircleOfNice/DoctrineRestDriver

Il s'agit d'une toute nouvelle façon de travailler avec les API.

Tout d'abord, vous définissez une entité qui définit la structure des données entrantes et sortantes et vous les annotez avec des sources de données:

/*
 * @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;
    }
}

Il est maintenant assez facile de communiquer avec 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();

Vous pouvez opter pour POSTMAN, une application qui facilite les API. Remplissez les champs de demande, puis il générera pour vous du code dans différentes langues. Cliquez simplement sur le code sur le côté droit et sélectionnez votre langue préférée.