hyper http php

Déprécié

Cette bibliothèque n'est pas en développement actif.

Veuillez considérer Guzzlehttp / Guzzle ou une autre bibliothèque à la place.

Correction de bug uniquement.

Client Hyper HTTP

Aperçu

Hyper est un client HTTP qui vise à fournir une interface simple mais puissante pour passer des appels HTTP et récupérer et manipuler les données d'API.

Pourquoi utiliser Hyper

• Interface extrêmement simple Hyper::get('http://some/url') .
• Prend également en charge le style d'objet Hyper::make(...)->get('http://some/url') .
• Fournit un objet Response qui fournit des informations utiles comme le code d'état HTTP, le corps et les en-têtes.
• Chaque Response se mélange dans REXLABS Array-Object qui vous permet d'interroger facilement les réponses API.
• Jette un ensemble limité d'exceptions (avec accès à la demande et / ou à la réponse) lorsque les choses tournent mal.
• Vous avez accès à la Request d'origine via $response->getRequest() .
• Prend en charge toutes les fonctionnalités du client Guzzle, y compris les flux.
• Vous permet de vider les demandes de couronne de reproduction à partir de la ligne de commande.
• Enregistrez facilement toutes les demandes

Usage

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

Installation

Pour installer dans votre projet:

composer require rexlabs/hyper-http

Exemples

Les méthodes RESTful renvoient tous un objet Response qui facilite l'interaction avec les réponses.

Exemple: utilisant des méthodes statiques

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

Exemple: travailler avec une API JSON

Étant donné que les réponses mélangent ArrayObject, vous pouvez facilement récupérer et manipuler les valeurs de la réponse:

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

Exemple: Définissez les en-têtes mondiaux et passez dans un enregistreur

Utilisez make() pour simplifier l'instanciation, puis configurer l'objet pour les demandes futures:

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

Exemple: instanciation via le constructeur

Pour obtenir un contrôle complet sur l'instanciation, utilisez le constructeur et passez dans une instance de guse:

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

Exemple: vidange d'une demande de boucle

Vous pouvez facilement générer une demande Curl pour exécuter à partir de la ligne de commande pour reproduire votre dernière demande:

 <?php
use Rexlabs  HyperHttp  Hyper ;

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

Sortir:

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éthodes HTTP

Hyper fournit les méthodes suivantes pour interagir avec les points de terminaison distants:

obtenir()

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

Envoyez une demande de GET HTTP et renvoyez la réponse:

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

$ response = $ hyper -> get ( ' /v1/people ' );

• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $query est un tableau facultatif de paramètres de requête qui sera annexé à l'URI.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

poste()

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

Envoyez une demande de publication HTTP et renvoyez la réponse:

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

$ response = $ hyper -> post ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);

• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $body est la charge utile. Si vous fournissez un tableau, il sera converti et transporté en JSON.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

Méthodes alternatives:

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

mettre()

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

Envoyez une demande de vente HTTP et renvoyez la réponse:

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

$ response = $ hyper -> put ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);

• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $body est la charge utile. Si vous fournissez un tableau, il sera converti et transporté en JSON.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

correctif()

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

Envoyez une demande de patch HTTP et renvoyez la réponse:

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

$ response = $ hyper -> patch ( ' /v1/people ' , [ ' name ' => ' Bob ' , ' age ' => 25 ]);

• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $body est la charge utile. Si vous fournissez un tableau, il sera converti et transporté en JSON.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

supprimer()

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

Envoyez une demande de suppression HTTP et renvoyez la réponse:

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

$ response = $ hyper -> delete ( ' /v1/people/1 ' );

• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $body est la charge utile en option. Si vous fournissez un tableau, il sera converti et transporté en JSON.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

appel()

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

Envoyez une demande HTTP générique en spécifiant la method comme premier argument.

 // 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 est le verbe http. Par exemple, par exemple GET ou quelque chose ne fait pas partie de la norme.
• $uri est une chaîne ou un Uri . Si la chaîne n'est pas absolue, elle sera ajoutée à l'URI de base.
• $body est la charge utile en option. Si vous fournissez un tableau, il sera converti et transporté en JSON.
• $headers sont un tableau en option des en-têtes (indexé par le nom d'en-tête) qui sera fusionné avec tous les en-têtes mondiaux.
• $options est un tableau en option des options du client Guzzle.

Méthodes de demande

Méthodes disponibles à partir de l'objet RexlabsHyperHttpMessageRequest :

geturi ()

Renvoie l'objet URIInterface qui résume l'uri / URL pour cette demande.

getMethod ()

Renvoyez le verbe de la méthode HTTP pour cette demande.

getheaders ()

Retur un tableau d'en-têtes pour cette Request

getcurl ()

Renvoie une demande de curl (String) adaptée à l'exécution de la ligne de commande. Utile pour les demandes de débogage.

Méthodes de réponse

Méthodes disponibles à partir de l'objet RexlabsHyperHttpMessageResponse :

getRequest ()

Renvoie l'objet RexlabsHyperHttpMessageRequest Associé à la Response

getCurlRequest ()

Renvoie une demande de curl (String) adaptée à l'exécution de la ligne de commande. Utile pour les demandes de débogage.

getStaturScode ()

Renvoyez le code d'état HTTP pour cette Response . Par exemple, par exemple 200

getReasonphrase ()

Renvoyez la phrase de raison HTTP associée au code d'état. Par exemple, par exemple "D'ACCORD"

isjson ()

Renvoie true s'il s'agit d'une réponse JSON.

toarray ()

Convertit une réponse JSON à un tableau et renvoie le tableau.

toObject ()

Convertit une réponse JSON à un ArrayObject

ArrayObject

Chaque objet Response a toutes les méthodes et fonctionnalités de la classe ArrayObject du package rexlabsarray-object .

Cela signifie sur la base de la charge utile de réponse suivante:

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

Vous pouvez remplir les fonctions suivantes:

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

Vous pouvez également appeler:

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

Configurer

Définir la configuration par défaut pour tous les clients (par défaut à [])

Hyper:: setDefaultConfig ( $ config );

Définir la configuration pour ce client (les valeurs remplaceront / fusionneront avec par défaut)

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

Enregistreur par défaut

Définissez le journaliste par défaut utilisé par tous les clients qui n'en fournissent pas.
Doit implémenter LoggerInterface (par défaut à NullLogger )

Hyper:: setDefaultLogger ( $ logger );

Bûche

Enregistrer la chaîne de curl pour toutes les demandes (nécessite un ensemble d'enregistreur)

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

Configage de Guzzle

Définissez la configuration passée sur le GuzzleClient sous-jacent

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

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

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

Tests

Pour exécuter des tests:

composer tests

Pour exécuter le rapport de couverture:

composer coverage

Le rapport de couverture est sorti à ./tests/report/index.html

Extension

Hyper permet une extension pour les clients personnalisés par:

• Stockage des instances distinctes pour chaque sous-classe d'Hyper pour une utilisation statique
  • L'utilisation statique de MyHyperSubclass renverra la bonne instance créée par MyHyperSubclass
  • L'utilisation statique de Hyper renverra l'instance correcte créée par Hyper
• Remplacer protected static function makeClient pour personnaliser la classe client (par exemple, remplacer new Client par new MyClient )
• Remplacer protected static function makeConfig pour personnaliser la configuration du client par défaut
• Remplacer protected static function makeGuzzleConfig pour personnaliser le client de Guzzle par défaut
• Remplacer protected static function getBaseUri pour fournir une base par défaut_uri au client

Contributif

Les contributions sont les bienvenues, veuillez soumettre une demande de traction ou créer un problème. Votre code soumis doit être formaté à l'aide des normes PSR-1 / PSR-2.

À propos

• Auteur: Jodie Dunlop
• Licence: MIT
• Copyright (C) 2018 Rex Software Pty Ltd