Inicio>código fuente PHP>Otras categorias
Descargar

Desapercibido

Esta biblioteca no está en desarrollo activo.

Considere GuzzleHttp/Guzzle u otra biblioteca en su lugar.

Solamente corrige el error.

Cliente Hyper HTTP

Descripción general

Hyper es un cliente HTTP que tiene como objetivo proporcionar una interfaz simple pero poderosa para hacer llamadas HTTP y obtener y manipular datos de API.

¿Por qué usar Hyper

  • Interfaz extremadamente simple Hyper::get('http://some/url') .
  • También es compatible con el estilo de objeto Hyper::make(...)->get('http://some/url') .
  • Proporciona un objeto Response que proporciona información útil como código de estado HTTP, cuerpo y encabezados.
  • Cada Response se mezcla en RexLabs Array-Object, que le permite interrogar fácilmente las respuestas de API.
  • Lanza un conjunto limitado de excepciones (con acceso a la solicitud y/o respuesta) cuando las cosas salen mal.
  • Tiene acceso a la Request original a través de $response->getRequest() .
  • Admite toda la funcionalidad del cliente Guzzle, incluidas las transmisiones.
  • Le permite volcar las solicitudes de curl para reproducir desde la línea de comandos.
  • Registre fácilmente todas las solicitudes

Uso 

 <?php
use Rexlabs  HyperHttp  Hyper ;

$ response = Hyper:: get ( ' http://openlibrary.org/subjects/love.json ' );

// The first book for 'love' is: Wuthering Heights
echo " The first book for ' { $ response -> name } ' is: { $ response -> works -> first ()-> title }n" ;

echo " Total works: { $ response -> works -> count ()} books n" ;

Instalación

Para instalar en su proyecto: 

composer require rexlabs/hyper-http

Ejemplos

Todos los métodos RESTFUL devuelven un objeto Response que simplifica la interacción con las respuestas.

Ejemplo: utilizando métodos estáticos 

 <?php
use Rexlabs  HyperHttp  Hyper ;

$ response = Hyper:: get ( ' https://example.com/url ' );
echo ' Status Code: ' . $ response -> getStatusCode (). "n" ;
echo ( string ) $ response ; // Output the response body

Ejemplo: trabajar con una API JSON

Dado que las respuestas mezclan ArrayObject, puede obtener y manipular valores fácilmente de la respuesta: 

 <?php
use Rexlabs  HyperHttp  Hyper ;

// Fetch historical price via CryptoCompare's public API for Ethereum
$ response = Hyper:: get ( ' https://min-api.cryptocompare.com/data/pricehistorical ' , [
    ' fsym ' => ' ETH ' ,
    ' tsyms ' => ' BTC,USD ' ,
    ' ts ' => ' 1452680400 ' ,
]);

// Output prices
printf ( " ETH->USD: %s n" , $ response -> get ( ' ETH.USD ' ));
printf ( " ETH->BTC: %s n" , $ response -> get ( ' ETH.BTC ' ));

Ejemplo: Establezca encabezados globales y pase en un registrador

Use make() para simplificar la instanciación y luego configurar el objeto para futuras solicitudes: 

 <?php
use Rexlabs  HyperHttp  Hyper ;
use Rexlabs  Logger  CustomLogger ;

$ hyper = Hyper:: make ()
    -> setBaseUri ( ' http://example.com/api/v1 ' )
    -> setHeader ( ' X-App-Identity ' , ' Some App ' )
    -> setHeader ( ' X-Correlation-Id ' , ' 12345 ' )
    -> setLogger ( new CustomLogger );
  • $hyper = Hyper::make(array $config = [], GuzzleHttpClient $guzzle, PsrLogLoggerInterface $logger)

Ejemplo: Instanciación a través del constructor

Para obtener un control completo sobre la instanciación, use el constructor y pase en una instancia de Guzzle: 

 <?php
use Rexlabs  HyperHttp  Client ;
use GuzzleHttp  Client as GuzzleClient ;
use Psr  Log  NullLogger ;

$ hyper = new Client ( new GuzzleClient (), new NullLogger (), [
   ' base_uri ' => ' http://example.com/api/v1 ' ,
   ' headers ' => [
       ' X-App-Identity ' => ' Some App ' ,
   ],
]);
$ response = $ hyper -> get ( ' /messages ' );

Ejemplo: descargar una solicitud de curl

Puede generar fácilmente una solicitud CURL para ejecutar desde la línea de comandos para reproducir su última solicitud: 

 <?php
use Rexlabs  HyperHttp  Hyper ;

echo Hyper:: get ( ' https://example.com/api/v1/resources ' )
    -> getCurlRequest ();

Producción: 

curl 
  ' https://min-api.cryptocompare.com/data/pricehistorical?fsym=ETH&tsyms=BTC%2CUSD&ts=1452680400&extraParams=your_app_name ' 
  -H ' Content-Type: application/json ' -H ' Accept: application/json '

Métodos HTTP

Hyper proporciona los siguientes métodos para interactuar con puntos finales remotos:

conseguir()

get(mixed $uri, array $query = [], array $headers = [], array $options = []): Response

Envíe una solicitud HTTP Get y devuelva la respuesta: 

 $ response = Hyper:: get ( ' https://example.com ' , [ ' sort ' => ' latest ' ], [ ' X-Greeting ' => ' Hello! ' ]);

$ response = $ hyper -> get ( ' /v1/people ' );
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $query es una matriz opcional de parámetros de consulta que se agregarán al URI.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

correo()

post(mixed $uri, mixed $body = null, array $headers = [], array $options = []): Response

Envíe una solicitud de publicación HTTP y devuelva la respuesta: 

 $ response = Hyper:: post ( ' https://example.com/fruit ' , ' apples ' );

$ response = $ hyper -> post ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $body es la carga útil. Si proporciona una matriz, se convertirá y transportará como JSON.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

Métodos alternativos:

  • $response = $hyper->postForm($uri, $formParams, $headers, $options);
  • $response = $hyper->postMultipartForm($uri, $formParams, $headers, $options);

poner()

put(mixed $uri, mixed $body = null, array $headers = [], array $options = []): Response

Envíe una solicitud de put HTTP y devuelva la respuesta: 

 $ response = Hyper:: put ( ' https://example.com/fruit ' , ' apples ' );

$ response = $ hyper -> put ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $body es la carga útil. Si proporciona una matriz, se convertirá y transportará como JSON.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

parche()

patch(mixed $uri, mixed $body = null, array $headers = [], array $options = []): Response

Envíe una solicitud de parche HTTP y devuelva la respuesta: 

 $ response = Hyper:: patch ( ' https://example.com/fruit ' , ' apples ' );

$ response = $ hyper -> patch ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $body es la carga útil. Si proporciona una matriz, se convertirá y transportará como JSON.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

borrar()

delete(mixed $uri, mixed $body = null, array $headers = [], array $options = []): Response

Envíe una solicitud de eliminación HTTP y devuelva la respuesta: 

 $ response = Hyper:: delete ( ' https://example.com/fruit ' , ' apples ' );

$ response = $ hyper -> delete ( ' /v1/people/1 ' );
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $body es la carga útil opcional. Si proporciona una matriz, se convertirá y transportará como JSON.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

llamar()

call(string $method, mixed $uri, mixed $body, array $headers, array $options): Response

Envíe una solicitud HTTP genérica especificando el method como el primer argumento. 

 // Statically
$ response = Hyper:: call ( ' MOVE ' , ' myfile1234 ' , [ ' new_location ' => ' some_folder ' ]);

// Http method verbs may also be invoked via method name
$ response = Hyper:: move ( ' myfile1234 ' , [ ' new_location ' => ' some_folder ' ]);
$ response = Hyper:: somethingelse (...);

// Via object
$ response = $ hyper -> call ( ' MOVE ' , ' myfile1234 ' , [ ' new_location ' => ' some_folder ' ]);
  • $method es el verbo http. P.ej. GET o algo que no sea parte del estándar.
  • $uri es una cadena o un Uri . Si la cadena no es absoluta, se agregará al URI base.
  • $body es la carga útil opcional. Si proporciona una matriz, se convertirá y transportará como JSON.
  • $headers es una matriz opcional de encabezados (indexada por el nombre del encabezado) que se fusionará con cualquier encabezado global.
  • $options es una variedad opcional de opciones de cliente Guzzle.

Métodos de solicitud

Métodos disponibles en el objeto RexlabsHyperHttpMessageRequest :

geturi ()

Devuelva el objeto Uriinterface que encapsula el URI/URL para esta solicitud.

getMethod ()

Devuelva el verbo de método HTTP para esta solicitud.

Getheaders ()

Returue una variedad de encabezados para esta Request

getCurl ()

Devuelva una solicitud CURL (cadena) adecuada para ejecutar desde la línea de comandos. Útil para solicitudes de depuración.

Métodos de respuesta

Métodos disponibles en el objeto RexlabsHyperHttpMessageResponse :

GetRequest ()

Devuelve el objeto RexlabsHyperHttpMessageRequest asociado con la Response

getCurlRequest ()

Devuelva una solicitud CURL (cadena) adecuada para ejecutar desde la línea de comandos. Útil para solicitudes de depuración.

getStatuscode ()

Devuelva el código de estado HTTP para esta Response . P.EJ. 200

getRasonPhrase ()

Devuelva la frase de razón HTTP asociada con el código de estado. P.EJ. "DE ACUERDO"

isjson ()

Devuelve true si esta es una respuesta JSON.

ToArray ()

Convierte una respuesta JSON a una matriz y devuelve la matriz.

toObject ()

Convierte una respuesta JSON a un ArrayObject

Arrayobject

Cada objeto Response tiene todos los métodos y funcionalidad de la clase ArrayObject del paquete rexlabsarray-object .

Esto significa basado en la siguiente carga útil de respuesta: 

{
  "books" : [
    {
      "id" : 1 ,
      "title" : " 1984 " ,
      "author" : " George Orwell "
    },
    {
      "id" : 2 ,
      "title" : " Pride and Prejudice " ,
      "author" : " Jane Austen "
    }
  ]
}

Puede realizar las siguientes funciones: 

 $ response -> books ; // Instance of ArrayObject
$ response -> books -> pluckArray ( ' author ' ); // array [ 'George Orwell', 'Jane Austen' ]
$ response -> pluckArray ( ' books.author ' ); // array [ 'George Orwell', 'Jane Austen' ]
$ response -> books -> count (); // 2
$ response -> books -> isCollection (); // true
$ response -> books [ 0 ]; // Instance of ArrayObject
$ response -> books [ 0 ]-> isCollection (); // false
$ response -> books [ 0 ]-> id ; // 1
$ response -> get ( ' books.1.title ' );    // "Pride and Prejudice"
foreach ( $ response -> books as $ book ) {
    echo "{ $ book -> title } by { $ book -> author }n" ;
}

También puedes llamar: 

 $ obj = $ response -> toObject ();   // Instance of Arraybject

Configuración

Establecer configuración predeterminada para todos los clientes (predeterminados a []) 

Hyper:: setDefaultConfig ( $ config );

Establecer config para este cliente (los valores anularán / fusionarán con el valor predeterminado) 

 $ client = Hyper:: make ( $ config );

Logger predeterminado

Establezca el registrador predeterminado utilizado por todos los clientes que no proporcionan uno.
Debe implementar LoggerInterface (predeterminado se encuentra a NullLogger ) 

Hyper:: setDefaultLogger ( $ logger );

Rizo de registro

Registre la cadena curl para todas las solicitudes (requiere un conjunto de registradores) 

 $ config = [
    ' log_curl ' => true ,
];

Configuración de guía

Establezca la configuración pasada al GuzzleClient subyacente 

 $ config = [
    ' guzzle ' => [
        ' verify ' => false ,
    ],
];

// Set for all clients
Hyper:: setDefaultConfig ( $ config );

// Set for one client
$ client = Hyper:: make ( $ config );

Pruebas

Para ejecutar pruebas: 

composer tests

Para ejecutar el informe de cobertura: 

composer coverage

El informe de cobertura se emite a ./tests/report/index.html

Extensión

Hyper permite la extensión para clientes personalizados por:

  • Almacenar instancias separadas para cada subclase de Hyper para uso estático
    • El uso estático de MyHyperSubclass devolverá la instancia correcta creada por MyHyperSubclass
    • El uso estático de Hyper devolverá la instancia correcta creada por Hyper
  • Anular protected static function makeClient para personalizar la clase de cliente (por ejemplo, reemplace new Client con new MyClient )
  • Anular protected static function makeConfig para personalizar la configuración del cliente predeterminada
  • Anular protected static function makeGuzzleConfig para personalizar el cliente GUzzle predeterminado
  • Anular protected static function getBaseUri para proporcionar una base_uri predeterminada al cliente

Que contribuye

Las contribuciones son bienvenidas, envíe una solicitud de extracción o cree un problema. Su código enviado debe formatearse utilizando estándares PSR-1/PSR-2.

Acerca de

  • Autor: Jodie Dunlop
  • Licencia: MIT
  • Copyright (c) 2018 REX Software Pty Ltd
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo