php - redirectresponse - Symfony2-Cómo realizar una solicitud externa

symfony request get all parameters

Question

Usando Symfony2, necesito acceder a una API externa basada en HTTPS.

¿Cómo puedo llamar a un URI externo y administrar la respuesta para "jugar" con él? Por ejemplo, para mostrar un mensaje de éxito o error?

Estoy pensando en algo como (note que performRequest es un método completamente inventado):

$response = $this -> performRequest("www.someapi.com?param1=A&param2=B");

if ($response -> getError() == 0){
    // Do something good
}else{
    // Do something too bad
}

He estado leyendo sobre Buzz y otros clientes. Pero supongo que Symfony2 debería poder hacerlo por sí mismo.

Answer 1

El mejor cliente que conozco es: http://docs.guzzlephp.org/en/latest/

Ya hay un paquete que lo integra en el proyecto Symfony2: https://github.com/8p/GuzzleBundle

$client   = $this->get(''guzzle.client'');

// send an asynchronous request.
$request = $client->createRequest(''GET'', ''http://httpbin.org'', [''future'' => true]);
// callback
$client->send($request)->then(function ($response) {
    echo ''I completed! '' . $response;
});

// optional parameters
$response = $client->get(''http://httpbin.org/get'', [
    ''headers'' => [''X-Foo-Header'' => ''value''],
    ''query''   => [''foo'' => ''bar'']
]);
$code = $response->getStatusCode();
$body = $response->getBody();

// json response
$response = $client->get(''http://httpbin.org/get'');
$json = $response->json();

// extra methods
$response = $client->delete(''http://httpbin.org/delete'');
$response = $client->head(''http://httpbin.org/get'');
$response = $client->options(''http://httpbin.org/get'');
$response = $client->patch(''http://httpbin.org/patch'');
$response = $client->post(''http://httpbin.org/post'');
$response = $client->put(''http://httpbin.org/put'');

Se puede encontrar más información en: http://docs.guzzlephp.org/en/latest/index.html

Answer 2

Symfony no tiene su propio cliente de descanso, pero como ya mencionaste, hay un par de paquetes. Este es mi preferido:

https://github.com/CircleOfNice/CiRestClientBundle

$restClient = $this->container->get(''ci.restclient'');

$restClient->get(''http://www.someUrl.com'');
$restClient->post(''http://www.someUrl.com'', ''somePayload'');
$restClient->put(''http://www.someUrl.com'', ''somePayload'');
$restClient->delete(''http://www.someUrl.com'');
$restClient->patch(''http://www.someUrl.com'', ''somePayload'');

$restClient->head(''http://www.someUrl.com'');
$restClient->options(''http://www.someUrl.com'', ''somePayload'');
$restClient->trace(''http://www.someUrl.com'');
$restClient->connect(''http://www.someUrl.com'');

Usted envía la solicitud a través de

$response = $restclient->get($url); 

y obtener un objeto de respuesta Symfony. A continuación, puede obtener el código de estado a través de

$httpCode = $response-> getStatusCode();

Su código se vería como:

$restClient = $this->container->get(''ci.restclient'');
if ($restClient->get(''http://www.yourUrl.com'')->getStatusCode !== 200) {
    // no error
} else {
    // error
}

Answer 3

Symfony no tiene un servicio incorporado para esto, pero esta es una oportunidad perfecta para crear el suyo propio, utilizando el marco de inyección de dependencias. Lo que puede hacer aquí es escribir un servicio para administrar la llamada externa. Llamemos al servicio "http".

Primero, escribe una clase con un método performRequest() :

namespace MyBundle/Service;

class Http
{    
    public function performRequest($siteUrl)
    {
        // Code to make the external request goes here
        // ...probably using cUrl
    }
}

Regístrelo como un servicio en app/config/config.yml :

services:
    http:
        class: MyBundle/Service/Http

Ahora su controlador tiene acceso a un servicio llamado "http". Symfony administra una sola instancia de esta clase en el "contenedor", y puedes acceder a ella a través de $this->get("http") :

class MyController
{
    $response = $this->get("http")->performRequest("www.something.com");

    ...
}

Answer 4

Yo sugeriría usar CURL:

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, ''www.someapi.com?param1=A&param2=B'');
curl_setopt($ch, CURLOPT_HTTPHEADER, array(''Content-type: application/json'')); // Assuming you''re requesting JSON
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

$response = curl_exec($ch);

// If using JSON...
$data = json_decode($response);

Nota: el php en su servidor web debe tener instalada la biblioteca php5-curl .

Suponiendo que la solicitud de la API está devolviendo datos JSON, esta página puede ser útil.

Esto no utiliza ningún código que sea específico de Symfony2. Puede que haya un paquete que pueda simplificar este proceso para usted, pero si lo hay, no lo sé.

Answer 5

https://github.com/sensio/SensioBuzzBundle parece ser lo que estás buscando.

Implementa la biblioteca de zumbidos de Kris Wallsmith para realizar solicitudes HTTP.

Te dejaré leer el documento en la página de github, el uso es bastante básico:

$buzz = $this->container->get(''buzz'');

$response = $buzz->get(''http://google.com'');

echo $response->getContent();