Rufen Sie eine REST API in PHP auf

Wenn Sie eine URL haben und diese von Ihrem PHP unterstützt wird, können Sie einfach file_get_contents aufrufen:

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

wenn $ response JSON ist, verwandle es mit json_decode in ein PHP-Array:

$response = json_decode($response);

wenn $ response XML ist, verwenden Sie die Klasse simple_xml:

$response = new SimpleXMLElement($response);

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

Verwenden Sie Guzzle . Es handelt sich um einen "PHP HTTP-Client, der die Arbeit mit HTTP/1.1 vereinfacht und den Aufwand für die Inanspruchnahme von Webdiensten verringert". Die Arbeit mit Guzzle ist viel einfacher als die Arbeit mit cURL.

Hier ist ein Beispiel von der Website:

$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 ist der einfachste Weg. Hier ist ein einfacher Anruf

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

Verwenden Sie HTTPFUL

Hilfreich ist eine einfache, verkettbare, lesbare PHP Bibliothek, die das Sprechen von HTTP vernünftig machen soll. Der Entwickler kann sich auf die Interaktion mit APIs konzentrieren, anstatt die Seiten von curl set_opt zu durchsuchen, und ist ein idealer PHP REST Client.

Hilfreich sind ...

• Unterstützung für lesbare HTTP-Methoden (GET, PUT, POST, DELETE, HEAD und OPTIONS)
• Benutzerdefinierte Header
• Automatisches "Smart" -Parsing
• Automatische Payload-Serialisierung
• Grundlegende Auth
• Client Side Certificate Auth
• Anfrage "Vorlagen"

Ex.

Senden Sie eine GET-Anfrage. Automatisch analysierte JSON-Antwort abrufen.

Die Bibliothek erkennt den JSON-Inhaltstyp in der Antwort und analysiert die Antwort automatisch in ein systemeigenes PHP -Objekt.

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

Sie müssen wissen, ob die REST API, die Sie aufrufen, GET oder POST oder beide Methoden unterstützt. Der folgende Code funktioniert für mich. Ich rufe meine eigene Web-Service-API auf, sodass ich bereits weiß, wie die API funktioniert und was sie zurückgibt. Es werden die Methoden GET und POST unterstützt, sodass die weniger vertraulichen Informationen in die Funktion URL (GET) eingehen und Informationen wie Benutzername und Kennwort als Variable POST übergeben werden. Außerdem geht alles über die Verbindung HTTPS.

Innerhalb des API-Codes codiere ich ein Array, das ich in das json-Format zurückgeben möchte, und verwende dann einfach den Befehl PHP _echo $my_json_variable_, um diese json-Zeichenfolge für den Client verfügbar zu machen.

Wie Sie sehen können, gibt meine API JSON-Daten zurück, Sie müssen jedoch wissen (oder die zurückgegebenen Daten überprüfen, um herauszufinden), in welchem ​​Format die Antwort von der API vorliegt.

So verbinde ich mich vom Client aus mit der API:

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

Übrigens habe ich auch versucht, die Methode file_get_contents() zu verwenden, wie einige der Benutzer hier vorgeschlagen haben, aber das funktioniert bei mir nicht gut. Ich fand heraus, dass die Methode curl schneller und zuverlässiger ist.

Es gibt tatsächlich viele Kunden. Einer von ihnen ist Pest - check this out. Beachten Sie, dass es sich bei diesen REST -Aufrufen um einfache http-Anforderungen mit verschiedenen Methoden handelt: GET, POST, PUT und DELETE.

Wenn Sie Symfony verwenden, gibt es ein großartiges Rest-Client-Bundle, das sogar alle ~ 100 Ausnahmen enthält und diese auslöst, anstatt einen bedeutungslosen Fehlercode und eine Fehlermeldung zurückzugeben.

Sie sollten es wirklich überprüfen: https://github.com/CircleOfNice/CiRestClientBundle

Ich liebe das Interface:

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

Funktioniert für alle http-Methoden.

Sie können file_get_contents verwenden, um alle http POST/PUT/DELETE/OPTIONS/HEAD -Methoden auszugeben, zusätzlich zur GET -Methode, wie der Funktionsname vorschlägt.

Wie poste ich Daten in PHP mit file_get_contents?

wie @Christoph Winkler erwähnte, ist dies eine Basisklasse, um dies zu erreichen:

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

}

Dann können Sie die Datei immer einbinden und verwenden, z. B .: 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)

Wenn Sie offen sind, Tools von Drittanbietern zu verwenden, sollten Sie sich diese ansehen: https://github.com/CircleOfNice/DoctrineRestDriver

Dies ist eine völlig neue Art, mit APIs zu arbeiten.

Zunächst definieren Sie eine Entität, die die Struktur eingehender und ausgehender Daten definiert, und versehen diese mit Anmerkungen zu Datenquellen:

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

Jetzt ist die Kommunikation mit der REST -API ziemlich einfach:

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

Sie können sich für POSTMAN entscheiden, eine Anwendung, die APIs einfach macht. Füllen Sie die Anforderungsfelder aus und es wird Code in verschiedenen Sprachen für Sie generiert. Klicken Sie einfach auf den Code auf der rechten Seite und wählen Sie Ihre bevorzugte Sprache aus.