restful - libreria rest php
Llame a una API REST en PHP (12)
Nuestro cliente me había dado una API REST a la que necesito hacer una llamada de PHP. Pero, de hecho, la documentación proporcionada con la API es muy limitada, por lo que realmente no sé cómo llamar al servicio.
He intentado buscarlo en Google, pero lo único que surgió fue un Yahoo! ya vencido. Tutorial sobre cómo llamar al servicio. Sin mencionar los encabezados ni nada de información en profundidad.
¿Hay alguna información decente sobre cómo llamar a una API REST, o alguna documentación al respecto? Porque incluso en W3schools, solo describen el método SOAP. ¿Cuáles son las diferentes opciones para hacer la API de descanso en PHP?
CURL es la forma más sencilla de ir. Aquí hay una simple llamada.
$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);
Hay muchos clientes en realidad. Uno de ellos es Pest - mira esto. Y tenga en cuenta que estas llamadas REST son una solicitud http simple con varios métodos: GET, POST, PUT y DELETE.
Necesitará saber si la API REST a la que está llamando admite GET o POST, o ambos métodos. El código a continuación es algo que me funciona, llamo a mi propia API de servicio web, por lo que ya sé qué es lo que toma la API y qué devolverá. Admite los métodos GET y POST, por lo que la información menos sensible se incluye en la URL (GET) y la información como el nombre de usuario y la contraseña se envía como variables POST. Además, todo pasa por la conexión HTTPS.
Dentro del código de la API, codifico una matriz que quiero volver al formato json, luego simplemente uso el comando PHP echo $ my_json_variable para hacer que la cadena json esté disponible para el cliente.
Como puede ver, mi API devuelve datos json, pero necesita saber (o mirar los datos devueltos para averiguar) en qué formato está la respuesta de la API.
Así es como me conecto a la API desde el lado del cliente:
$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;
}
Por cierto, también intenté usar el método file_get_contents () como algunos de los usuarios sugirieron aquí, pero eso no me funciona bien. Descubrí que el método de rizo es más rápido y más confiable.
Puede usar file_get_contents para emitir cualquier método http POST / PUT / DELETE / OPTIONS / HEAD, además del método GET como lo sugiere el nombre de la función.
Puedes ir con POSTMAN, una aplicación que facilita las API. Rellene los campos de solicitud y luego generará el código para usted en diferentes idiomas. Simplemente haga clic en el código en el lado derecho y seleccione su idioma preferido.
Si está abierto a utilizar herramientas de terceros, eche un vistazo a este: https://github.com/CircleOfNice/DoctrineRestDriver
Esta es una forma completamente nueva de trabajar con API.
En primer lugar, define una entidad que define la estructura de los datos entrantes y salientes y la anota con fuentes de datos:
/*
* @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;
}
}
Ahora es bastante fácil comunicarse con la 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();
Si estás usando Symfony, hay un gran paquete de cliente de descanso que incluso incluye todas las ~ 100 excepciones y las lanza en lugar de devolver algún código de error sin sentido + mensaje.
Realmente deberías comprobarlo: https://github.com/CircleOfNice/CiRestClientBundle
Me encanta la interfaz:
try {
$restClient = new RestClient();
$response = $restClient->get(''http://www.someUrl.com'');
$statusCode = $response->getStatusCode();
$content = $response->getContent();
} catch(OperationTimedOutException $e) {
// do something
}
Funciona para todos los métodos http.
Si tiene una url y su php lo admite, simplemente puede llamar a file_get_contents:
$response = file_get_contents(''http://example.com/path/to/api/call?param1=5'');
Si $ response es JSON, use json_decode para convertirlo en php array:
$response = json_decode($response);
Si $ response es XML, use la clase simple_xml:
$response = new SimpleXMLElement($response);
Utilice Guzzle . Es un "cliente PHP PHP que facilita el trabajo con HTTP / 1.1 y evita el consumo de servicios web". Trabajar con Guzzle es mucho más fácil que trabajar con cURL.
Aquí hay un ejemplo del sitio 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
Utilizar HTTPFUL
Httpful es una biblioteca de PHP fácil de leer, fácil de usar y con la intención de que HTTP sea sensato al hablar. Le permite al desarrollador enfocarse en interactuar con las API en lugar de revisar las páginas de curl set_opt y es un cliente ideal de REST de PHP.
Httpful incluye ...
- Compatibilidad con el método HTTP legible (GET, PUT, POST, DELETE, HEAD y OPTIONS)
- Encabezados personalizados
- Análisis "inteligente" automático
- Serialización automática de la carga útil
- Autentica Básica
- Certificado del lado del cliente
- Solicitar "Plantillas"
Ex.
Enviar una solicitud GET. Obtener automáticamente la respuesta JSON analizada.
La biblioteca observa el tipo de contenido JSON en la respuesta y la analiza automáticamente en un objeto 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";
como mencionó @Christoph Winkler, esta es una clase base para lograrlo:
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;
}
}
Entonces siempre puedes incluir el archivo y usarlo, por ejemplo: 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)
Puede acceder a cualquier API REST con PHPs cURL Extension. Sin embargo, la documentación de la API (métodos, parámetros, etc.) debe ser proporcionada por su cliente.
Ejemplo:
// 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;
}