Página Inicial>Código fonte PHP>Outras categorias
Baixar

Descontinuado

Esta biblioteca não está em desenvolvimento ativo.

Por favor, considere o Guzzlehttp/Guzzle ou outra biblioteca.

Apenas correções de bug.

Cliente http hyper

Visão geral

A Hyper é um cliente HTTP que visa fornecer uma interface simples, mas poderosa, para fazer chamadas HTTP e buscar e manipular dados da API.

Por que usar hiper

  • Interface extremamente simples Hyper::get('http://some/url') .
  • Também suporta Hyper::make(...)->get('http://some/url') .
  • Fornece um objeto Response que fornece informações úteis, como código de status HTTP, corpo e cabeçalhos.
  • Cada Response se mistura no REXLABS Array-Object, que permite interrogar facilmente as respostas da API.
  • Joga um conjunto limitado de exceções (com acesso à solicitação e/ou resposta) quando as coisas dão errado.
  • Você tem acesso à Request original via $response->getRequest() .
  • Suporta toda a funcionalidade do cliente Guzzle, incluindo fluxos.
  • Permite despejar solicitações de CURL para reprodução da linha de comando.
  • Registre facilmente todas as solicitações

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

Instalação

Para instalar em seu projeto: 

composer require rexlabs/hyper-http

Exemplos

Todos os métodos RESTful retornam um objeto Response que simplifica a interação com as respostas.

Exemplo: Usando 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

Exemplo: Trabalhando com uma API JSON

Como as respostas Mixin ArrayObject você pode buscar facilmente e manipular valores da resposta: 

 <?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 ' ));

Exemplo: defina cabeçalhos globais e passe em um madeireiro

Use make() para simplificar a instanciação e configurar o objeto para solicitações futuras: 

 <?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)

Exemplo: Instanciação via construtor

Para obter controle completo sobre a instanciação, use o construtor e passe em uma instância de desfiladeiro: 

 <?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 ' );

Exemplo: despejar uma solicitação de CRO

Você pode gerar facilmente uma solicitação de CLO para fugir da linha de comando para reproduzir sua última solicitação: 

 <?php
use Rexlabs  HyperHttp  Hyper ;

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

Saída: 

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

O Hyper fornece os seguintes métodos para interagir com pontos de extremidade remotos:

pegar()

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

Envie uma solicitação HTTP e retorne a resposta: 

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

$ response = $ hyper -> get ( ' /v1/people ' );
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $query é uma matriz opcional de parâmetros de consulta que será anexada ao URI.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

publicar()

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

Envie uma solicitação de postagem HTTP e retorne a resposta: 

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

$ response = $ hyper -> post ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $body é a carga útil. Se você fornecer uma matriz, ela será convertida e transportada como JSON.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

Métodos alternativos:

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

colocar()

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

Envie uma solicitação de put http e devolva a resposta: 

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

$ response = $ hyper -> put ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $body é a carga útil. Se você fornecer uma matriz, ela será convertida e transportada como JSON.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

correção()

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

Envie uma solicitação de patch http e retorne a resposta: 

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

$ response = $ hyper -> patch ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $body é a carga útil. Se você fornecer uma matriz, ela será convertida e transportada como JSON.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

excluir()

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

Envie uma solicitação de exclusão http e retorne a resposta: 

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

$ response = $ hyper -> delete ( ' /v1/people/1 ' );
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $body é a carga útil opcional. Se você fornecer uma matriz, ela será convertida e transportada como JSON.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

chamar()

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

Envie uma solicitação HTTP genérica especificando o method como o primeiro 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 é o verbo http. Por exemplo. GET ou algo não parte do padrão.
  • $uri é uma string ou Uri . Se a string não for absoluta, ela será anexada ao URI base.
  • $body é a carga útil opcional. Se você fornecer uma matriz, ela será convertida e transportada como JSON.
  • $headers é uma variedade opcional de cabeçalhos (indexados pelo nome do cabeçalho) que será fundido com quaisquer cabeçalhos globais.
  • $options é uma matriz opcional de opções de clientes do Guzzle.

Métodos de solicitação

Métodos disponíveis no objeto RexlabsHyperHttpMessageRequest :

geturi ()

Retorne o objeto Uriinterface que encapsula o URI/URL para esta solicitação.

getMethod ()

Retorne o verbo do método HTTP para esta solicitação.

GETHEADERS ()

Retur uma variedade de cabeçalhos para este Request

getCurl ()

Retorne uma solicitação de curl (string) adequada para fugir da linha de comando. Útil para depurar solicitações.

Métodos de resposta

Métodos disponíveis no objeto RexlabsHyperHttpMessageResponse :

getRequest ()

Retorne o objeto RexlabsHyperHttpMessageRequest associado à Response

getCurlRequest ()

Retorne uma solicitação de curl (string) adequada para fugir da linha de comando. Útil para depurar solicitações.

getStatuscode ()

Retorne o código de status HTTP para esta Response . Por exemplo. 200

getReasonphrase ()

Retorne a frase de razão HTTP associada ao código de status. Por exemplo. "OK"

isjson ()

Retorna true se esta for uma resposta JSON.

ToArray ()

Converte uma resposta JSON em uma matriz e retorna a matriz.

toObject ()

Converte uma resposta JSON em um ArrayObject

ArrayObject

Todo objeto Response possui todos os métodos e funcionalidades da classe ArrayObject do pacote rexlabsarray-object .

Isso significa com base na seguinte carga útil de resposta: 

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

Você pode executar as seguintes funções: 

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

Você também pode ligar: 

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

Config

Defina a configuração padrão para todos os clientes (padrões para []) 

Hyper:: setDefaultConfig ( $ config );

Defina a configuração para este cliente (os valores substituirão / se fundirão com o padrão) 

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

Logger padrão

Defina o logger padrão usado por todos os clientes que não fornecem um.
Deve implementar LoggerInterface (padrão para NullLogger ) 

Hyper:: setDefaultLogger ( $ logger );

Log Curl

Logre a string CURL para todas as solicitações (requer um conjunto de madeireiros) 

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

Config Guzzle

Defina a configuração passada para o GuzzleClient subjacente 

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

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

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

Testes

Para executar testes: 

composer tests

Para executar o relatório de cobertura: 

composer coverage

O relatório de cobertura é emitido para ./tests/report/index.html

Estendendo -se

O Hyper permite extensão para clientes personalizados por:

  • Armazenar instâncias separadas para cada subclasse de hiper para uso estático
    • O uso estático da MyHyperSubclass retornará a instância correta criada por MyHyperSubclass
    • O uso estático de Hyper retornará a instância correta criada por Hyper
  • Substitua protected static function makeClient para personalizar a classe Client (por exemplo, substitua new Client pelo new MyClient )
  • Substitua protected static function makeConfig para personalizar a configuração padrão do cliente
  • Substitua protected static function makeGuzzleConfig para personalizar o cliente Guzzle padrão
  • Substitua protected static function getBaseUri para fornecer uma base padrão base para o cliente

Contribuindo

As contribuições são bem-vindas, envie uma solicitação de tração ou crie um problema. Seu código enviado deve ser formatado usando os padrões PSR-1/PSR-2.

Sobre

  • Autor: Jodie Dunlop
  • Licença: MIT
  • Copyright (C) 2018 Rex Software Pty Ltd
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos