Se libérer de Guzzle5 avec PHP-HTTP et HTTPLUG

Les plats clés

• httplug, un projet de PHP-HTTP, permet une injection facile de tout client HTTP dans un SDK, fournissant une solution pour des applications qui ont déjà un client HTTP préféré et souhaitent éviter d'utiliser Guzzle.
• Le package d'interface HTTPLUG et Guzzle 6 peuvent être retirés ensemble à l'aide de la commande compositeur de compositeur PHP-HTTP / Guzzle6-Adapter. Cela permet d'utiliser Guzzle 6 ou tout autre adaptateur implémentant l'interface httpclient de HTTPLUG.
• Le projet PHP-HTTP vise à avoir une prise en charge maximale pour tous les clients HTTP dans PHP, y compris Guzzle 5 et 6, et Zend1 et 2. Cela ne permet aucun conflit avec les versions clients installées et le branchement facile de l'adaptateur approprié.
• Le SDK Diffbot a été rendu compatible PSR-7 et réceptif d'autres implémentations de clients HTTP. Il n'a besoin que d'un adaptateur qui respecte l'interface httplug pour que tout fonctionne hors de la boîte.
• HTTPLUG fournit une nouvelle approche pour abstraction des implémentations des clients HTTP dans les applications, offrant une extensibilité au coût d'une couche supplémentaire d'abstraction.

Cet article a été revu par des pairs par Márk Sági-Kazár et David Buchmann. Merci à tous les pairs examinateurs de SitePoint pour avoir fait du contenu SitePoint le meilleur possible!

---

Dans une série précédente, nous avons construit un client PHP pour Diffbot. Le client fonctionne bien et est en usage relativement répandu - nous l'avons même testé sur une application en direct pour nous assurer qu'elle est à la hauteur - mais cela dépend fortement de Guzzle 5.

Il y a deux problèmes à ce sujet:

1. Guzzle 6 est sorti et soutient le PSR 7. Bien que l'auteur de Guzzle affirme que Guzzle 5 sera soutenu dans un avenir prévisible, il est plus sûr d'être sceptique quant à sa longévité. De plus, bien que PSR 7 puisse avoir ses bizarreries, il est bon de suivre les PSR ne serait-ce que pour la compatibilité avec d'autres projets
2. quelqu'un qui implémente notre client dans son application pourrait déjà avoir un client HTTP préféré et aimerait utiliser le leur plutôt que Guzzle. Nous devons permettre une injection facile de tout client http dans notre SDK.

par coïncidence, il y a un nouveau projet nous permet de faire exactement cela: httplug.

Remarque: vous n'avez pas besoin de vous familiariser avec la logique interne du SDK Diffbot à suivre. Le processus de cet article est applicable à tout package avec une implémentation du client HTTP en béton et est facile à suivre.

php-http et httplug

PHP-HTTP est une organisation GitHub pour les outils liés à HTTP dans PHP. Il fournit HTTPLUG, une collection d'interfaces et d'exceptions pour définir un contrat client HTTP minimal en plus de la demande et de la réponse PSR-7. Les implémentations de ce contrat fournissent le package virtuel PHP-HTTP / Client-Implementation.

Cela signifie que quelqu'un qui utilise Guzzle 6 peut le compositeur nécessite un adaptateur PHP-HTTP / Guzzle6 pour tirer l'adaptateur, le package d'interface HTTPLUG et Guzzle 6 lui-même comme dépendance de l'adaptateur.

httplug est le point d'entrée d'un package réutilisable. Il s'agit de l'abstraction du client que tous les clients (comme l'adaptateur Guzzle6) sont basés. Ces clients utilisent ensuite davantage leurs packages / dépendances sous-jacents - Guzzle 6 dans ce cas.

donc, en bas en haut:

• Un client HTTP existe (Guzzle 6)
• Un adaptateur Guzzle 6 est construit avec httplug comme interface pour lui, enveloppe Guzzle 6
• Une application qui doit être en mesure de faire des appels HTTP a besoin d'un client, nécessite l'interface httpclient de HTTPlug plutôt que Guzzle 6 directement
• L'application peut ensuite utiliser Guzzle 6, ou tout autre adaptateur implémentant l'interface HTTPClient de HTTPLUG et enveloppant un autre client HTTP tiers

Le plan de l'équipe est d'avoir éventuellement un support maximal pour tous les différents clients HTTP dans PHP Land: Guzzle 6, Guzzle 5, Zend2, Zend1, etc. De cette façon, un utilisateur d'un cadre ou d'une application n'aura aucun conflit avec installé avec installé Versions client, et branchera simplement l'adaptateur approprié dans le mix.

Notez que nous utilisons les termes adaptateur et client ici presque interchangeables - les adaptateurs basés sur HTTPLUG sont les deux. Ce sont des emballages autour des clients existants, mais utilisés directement comme clients eux-mêmes.

Notre plan dans ce post est de remplacer la dépendance de béton de béton 5 du client PHP de Diffbot par la version httplug.

Remarque: Httplug et les packages associés sont des logiciels Alpha et, en tant que tels, sont susceptibles de changer. La conversion de tout pour les utiliser est une entreprise risquée.

bootstrap

Comme d'habitude, il est recommandé que nous utilisons Homestead améliorée pour bootstrap notre environnement. Une fois que nous sommes prêts, nous pouvons cloner et tester la version stable actuelle du SDK:

git clone https://github.com/swader/diffbot-php-client
cd diffbot-php-client 
git checkout tags/0.4.5 
composer install
phpunit

La dernière commande suppose que le phpunit est installé à l'échelle mondiale sur l'environnement de développement.

Tous les tests doivent passer (à l'exception d'un bogue sauté et non inacroprié en raison de certaines bêtises), nous sommes donc prêts à commencer la conversion.

Pour commencer

Tout d'abord, nous devons créer une nouvelle branche sur laquelle développer cette mise à niveau.

git checkout -b feature-httplug

Ensuite, nous ajoutons deux dépendances dans notre fichier composer.json:

git clone https://github.com/swader/diffbot-php-client
cd diffbot-php-client 
git checkout tags/0.4.5 
composer install
phpunit

ce que cela fait, c'est dire au client que désormais, cela dépend d'un package virtuel - celui-ci. Cela signifie que pour être utilisé, l'application utilisant notre client Diffbot (comme celle-ci) doit sélectionner une implémentation de ce package (l'un de ceux répertoriés sur le lien sur Packagist). Bien sûr, lors du développement du package, il serait impossible de tester et de voir si tout fonctionne sans une implémentation réelle, nous spécifions donc une dépendance supplémentaire à DEV. Dans le cas spécifique ci-dessus, nous utilisons "PHP-http / Guzzle6-adapter": "~0.2@dev". Nous avons choisi cette version particulière simplement parce que c'est la plus récente et qu'il n'y a pas de version stable.

Remarque: Vous vous demandez peut-être pourquoi nous avons utilisé l'approche de l'ajout de valeurs dans Composer.json plutôt que de déclarer les dépendances de manière interactive dans le terminal comme nous le faisons habituellement. En effet, faire un compositeur nécessite sur un package virtuel lancera une erreur - le package n'existe pas vraiment, c'est juste son nom virtuel, un espace réservé, donc le compositeur sera confus sans savoir quoi installer. Il y a un problème suggérant un changement à cela, mais cela ne se produit pas bientôt.

Étant donné que les packages PHP-HTTP sont toujours en cours de développement lourd, nous devons ajouter les deux valeurs suivantes à notre fichier composer.json:

git checkout -b feature-httplug

Il s'agit de permettre l'installation de packages de développement (non stable), mais préférera les versions stables si elles existent. Ainsi, plutôt que de récupérer, disons, phpunit 5.2.x qui est très instable, il va récupérer 5.0.8 (le plus à jour au moment de la rédaction), mais il réussira également si nous lui demandons des packages qui n'ont pas STABLES LIBÉRATIONS (comme l'adaptateur Guzzle6).

Nous devons également retirer la dépendance de Guzzle5, si nous avons l'intention d'installer Guzzle6. Les blocs d'exigences finaux ressemblent à ceci:

	"require": {
        ...
        "php-http/client-implementation": "^1.0"
    },
    "require-dev": {
        ...
        "php-http/guzzle6-adapter": "~0.2@dev"
    },

le plan

La façon dont le SDK fonctionne actuellement est la suivante: dans la classe Diffbot principale, nous définissons éventuellement un httpclient. Ceci est actuellement lié à l'implémentation de Guzzle à la version 5. Si aucune instance client personnalisée n'est définie, la classe Diffbot utilise automatiquement un client par défaut.

Ce client est ensuite utilisé par la méthode d'appel de l'API Résumé pour émettre une demande GET à l'URL donnée. De plus, il existe une méthode d'appel personnalisée dans la classe API Crawl et la classe API de recherche.

Le résultat de l'appel est enregistré comme une réponse $, qui est une réponse Guzzle5. Cette réponse est ensuite traitée en outre par l'usine d'entité qui vérifie sa validité et construit des entités à partir de celle-ci, les poussant dans l'itérateur d'entité.

Le plan est ainsi, à:

1. Remplacez Diffbot :: SethttpClient par une méthode acceptant une implémentation HTTPLUG
2. Modifiez les méthodes d'appel des abstraits, des crawls et de la classe de recherche afin qu'ils puissent émettre une demande GET avec toute implémentation du client HTTP qui leur est fournie.
3. Modifiez l'utérateur d'usine et d'entité d'entité afin qu'ils ne dépendent plus de la version Guzzle5 de la réponse, mais plutôt de l'homologue PSR-7.

Le projet PHP-HTTP a un package supplémentaire, Utils, qui contient httpMethodsClient. Cette classe enroule une usine de messages et le client HTTP en un tout, ce qui facilite l'envoi de demandes avec des verbes couramment utilisés comme Get, Post, etc. - traduisant ainsi quelque chose de similaire à ce que nous avions jusqu'à présent: $ client-> get (. ..). De plus, il renvoie également le PSR-7 Response Interface, ce qui signifie que la méthode GetBody sera disponible pour nous - qui ne laissera que la méthode Tojson sans implément, quelque chose que nous pouvons facilement faire nous-mêmes.

De plus, le projet a un composant de découverte, qui propose des classes statiques pour découvrir des usines et des clients installés - cela nous permet de fournir à notre utilisateur final une expérience de configuration zéro dans certains cas (voir les documents).

Avec le plan de bataille présenté, nous pouvons commencer avec le refactoring.

Prérequis

Besquions les packages supplémentaires:

git clone https://github.com/swader/diffbot-php-client
cd diffbot-php-client 
git checkout tags/0.4.5 
composer install
phpunit

Classe diffbot

La classe diffbot a cette ligne en haut:

git checkout -b feature-httplug

Nous pouvons simplement le changer en:

	"require": {
        ...
        "php-http/client-implementation": "^1.0"
    },
    "require-dev": {
        ...
        "php-http/guzzle6-adapter": "~0.2@dev"
    },

La méthode SethttpClient devrait évaser dans l'IDE maintenant, affirmant qu'il manque des paramètres requis, à savoir le client à utiliser, et l'usine de messages avec laquelle créer des instances de demande.

La méthode doit être refactorisée dans:

"prefer-stable": true,
"minimum-stability": "dev"

Alternativement, les classes de découverte peuvent être importées avec des instructions d'utilisation en haut de la classe.

Ce changement a maintenant permis à l'utilisateur final du SDK diffbot soit:

• faire installer son propre client et laisser les composants de découverte en tandem avec httpMethodsclient prendre soin des choses automatiquement, ou
• Configurez leur propre instance httpMethodsClient en injectant une instance personnalisée d'un client et d'une usine de messages PSR 7 dans une nouvelle instance de celui-ci, et injectez que dans la méthode Sethttpclient pour la pleine flexibilité

La plupart des utilisateurs l'utiliseront sur le pilote automatique.

API Résumé, Crawl et Search

Ensuite, les méthodes d'appel.

Étant donné que l'instance httpMethodsClient que nous avons implémentée auparavant a une méthode GET, aucun changement n'est nécessaire à cet égard. L'instance de réponse $, cependant, montre un Mistmatch, et pour raison. La réponse $ originale attendue par l'entitéfactory est une réponse Guzzle5.

En raison de la plainte émise par EntityFactory, nous n'avons pas vraiment besoin de modifier le résumé de l'API - il s'occupera des choses en soi. Le homologue de l'appel de la classe Crawl est un peu différent:

git clone https://github.com/swader/diffbot-php-client
cd diffbot-php-client 
git checkout tags/0.4.5 
composer install
phpunit

Deux avertissements ici - la deuxième ligne de la méthode qui utilise la méthode JSON de $ Response, et l'instanciation entityiterator qui attend une réponse Guzzle5. La seule ligne que nous pouvons affecter à partir d'ici est la première, alors changeons-la en:

git checkout -b feature-httplug

Un changement similaire doit être effectué dans la méthode d'appel de la classe de recherche, où la ligne:

	"require": {
        ...
        "php-http/client-implementation": "^1.0"
    },
    "require-dev": {
        ...
        "php-http/guzzle6-adapter": "~0.2@dev"
    },

se transforme en:

"prefer-stable": true,
"minimum-stability": "dev"

Entité Factory

La classe EntityFactory a l'importation suivante en haut:

    "require": {
        "php" : ">=5.4.0",
        "php-http/client-implementation": "^1.0"
    },
    "require-dev": {
        "symfony/var-dumper": "~2",
        "phpunit/phpunit": "^5.0",
        "php-http/guzzle6-adapter": "~0.2@dev"
    },

Nous pouvons changer cela en:

composer require "php-http/utils" "php-http/discovery"

La même chose doit être effectuée dans l'interface EntityFactory que la classe EntityFactory implémente.

L'autre changement est similaire à ce que nous avons fait ci-dessus, dans la classe de rampe. Nous changeons:

use GuzzleHttp\Client;

à

use Http\Client\Utils\HttpMethodsClient as Client;

dans les méthodes de vérification de la réponse et de la création des méthodes.

ITERATOR ENTITY

nous changeons:

<span>/**
</span><span> * Sets the client to be used for querying the API endpoints
</span><span> *
</span><span> * <span>@param Client $client
</span></span><span> * <span>@see http://php-http.readthedocs.org/en/latest/utils/#httpmethodsclient
</span></span><span> * <span>@return $this
</span></span><span> */
</span><span>public function setHttpClient(Client $client = null)
</span><span>{
</span>    <span>if ($client === null) {
</span>		<span>$client = new Client(
</span>		   <span><span>\Http\Discovery\HttpClientDiscovery</span>::find(),
</span>		   <span><span>\Http\Discovery\MessageFactoryDiscovery</span>::find()
</span>		<span>);
</span>    <span>}
</span>    <span>$this->client = $client;
</span>    <span>return $this;
</span><span>}
</span>

à

<span>public function call()
</span><span>{
</span>    <span>$response = $this->diffbot->getHttpClient()->get($this->buildUrl());
</span>
    <span>$array = $response->json();
</span>
    <span>if (isset($array['jobs'])) {
</span>        <span>$jobs = [];
</span>        <span>foreach ($array['jobs'] as $job) {
</span>            <span>$jobs[] = new JobCrawl($job);
</span>        <span>}
</span>
        <span>return new EntityIterator($jobs, $response);
</span>    <span>} elseif (!isset($array['jobs']) && isset($array['response'])) {
</span>        <span>return $array['response'];
</span>    <span>} else {
</span>        <span>throw new DiffbotException('It appears something went wrong.');
</span>    <span>}
</span><span>}
</span>

tests

La moquerie, la principale façon de tester les demandes HTTP et les appels API, est différente dans Guzzle 6, donc nos tests ont besoin d'une refonte légèrement plus grande.

Comme ce tutoriel est déjà un peu long, veuillez consulter la branche de fonctionnalité pertinente si vous êtes intéressé à apprendre les différences de moquerie entre Guzzle 5 et Guzzle 6 et, en particulier, entre les deux versions du SDK Diffbot .

Enfin, exécutons les tests:

$array = json_decode($response->getBody(), true);

Succès! Tous les passes (sauf le test sauté attendu).

Le SDK Diffbot est désormais non seulement compatible PSR-7, mais également réceptif d'autres implémentations de clients HTTP. Tout ce dont il a besoin est un adaptateur concernant l'interface HTTPLUG, et tout devrait fonctionner hors de la boîte.

Conclusion

HTTPLUG est une nouvelle approche utile pour abstraction des implémentations du client HTTP dans les applications que nous créons. Que nous construisions nous-mêmes des clients HTTP ou que nous les utilisons dans d'autres applications, PHP-HTTP fournit un tout nouveau monde d'extensibilité pour le prix raisonnable d'une couche supplémentaire d'abstraction.

Si vous souhaitez aider en ajoutant plus d'implémentations d'adaptateur, ou simplement en essayant les packages et en donnant des commentaires, l'équipe accueille toutes les contributions. Contactez-nous ou laissez vos commentaires dans la section des commentaires ci-dessous, et si vous avez trouvé ce tutoriel intéressant, n'oubliez pas de frapper ce bouton comme

Questions fréquemment posées (FAQ) sur PHP HTTP et HTTPLUG

Quelle est la différence entre Guzzle5 et Php Http / Httplug?

Guzzle5 et PHP HTTP / HTTPLUG sont tous deux les clients HTTP utilisés dans PHP. Guzzle5 est un client HTTP spécifique, tandis que PHP HTTP est une couche d'abstraction qui vous permet d'utiliser n'importe quel client HTTP. HTTPLUG est une extension de PHP HTTP qui fournit des fonctionnalités supplémentaires. La principale différence est que PHP HTTP et HTTPLUG permettent plus de flexibilité et d'interopérabilité, car ils ne sont pas liés à un client HTTP spécifique.

Comment migrer de Guzzle5 vers PHP HTTP / Httplug?

La migration de Guzzle5 vers PHP HTTP / HTTPLUG consiste à remplacer le client Guzzle5 par un adaptateur qui implémente les interfaces PHP HTTP. Cela peut être fait en utilisant la bibliothèque HTTPLUG, qui fournit des adaptateurs pour divers clients HTTP, y compris Guzzle5. Une fois l'adaptateur configuré, vous pouvez utiliser les méthodes PHP HTTP pour envoyer des demandes et gérer les réponses.

Quels sont les avantages de l'utilisation de PHP HTTP / HTTPLUG sur Guzzle5?

Le principal avantage de L'utilisation de PHP HTTP / HTTPLUG sur Guzzle5 est l'augmentation de la flexibilité et de l'interopérabilité. Avec PHP HTTP / HTTPLUG, vous pouvez basculer entre différents clients HTTP sans modifier votre code. Cela facilite le test de votre application avec différents clients et de changer de clients si nécessaire. De plus, HTTPLUG fournit un système de plugin qui vous permet d'ajouter des fonctionnalités à votre client HTTP.

Comment installer PHP HTTP / HTTPLUG?

PHP HTTP / HTTPLUG peut être installé à l'aide de Composer, A AP Outil de gestion des dépendances pour PHP. Vous pouvez l'installer en exécutant le compositeur de commande exiger php-http / httplug. Cela téléchargera la bibliothèque httplug et ses dépendances.

Comment utiliser PHP HTTP / HTTPLUG pour envoyer une demande?

Pour envoyer une demande avec PHP http / httplug, vous devez d'abord créer un objet de demande. Cela peut être fait en utilisant la méthode CreateRequest de l'interface MessageFactory. Une fois que vous avez un objet de demande, vous pouvez l'envoyer en utilisant la méthode SendRequest de l'interface httpclient.

Comment gérer les réponses avec PHP http / httplug?

Les réponses dans PHP http / httplug sont représenté par l'interface réponse Interface. Vous pouvez accéder au code d'état, aux en-têtes et au corps de la réponse à l'aide des méthodes GetStaturcode, Getheaders et GetBody, respectivement.

Quel est le but du composant Discovery dans PHP http / httplug?

Le composant Discovery dans PHP HTTP / HTTPLUG est utilisé pour trouver et utiliser automatiquement les adaptateurs HTTP disponibles et les usines de message. Cela facilite la commutation entre les différents clients HTTP et d'utiliser la meilleure implémentation disponible.

Comment utiliser le composant Discovery dans PHP HTTP / HTTPLUG?

Le composant Discovery peut être utilisé par Appeler la méthode de recherche statique sur les classes httpclientdiscovery ou messagefactorydiscovery. Cela renverra une instance du premier client ou usine de messages HTTP disponible.

Quels sont les plugins dans httplug et comment puis-je les utiliser?

Les plugins dans HTTPLUG sont utilisés pour ajouter des fonctionnalités au client HTTP. Ils peuvent être utilisés pour ajouter des fonctionnalités telles que l'authentification, la mise en cache et la gestion des erreurs. Les plugins peuvent être ajoutés au client à l'aide de la méthode AddPlugin de la classe PluginClient.

Comment gérer les erreurs dans PHP HTTP / HTTPLUG?

Les erreurs dans PHP HTTP / HTTPLUG sont représentées par des exceptions qui Implémentez l'interface HTTPClientException. Vous pouvez prendre ces exceptions et les gérer au besoin. De plus, vous pouvez utiliser l'erreur Plugin pour convertir automatiquement les réponses non-200 en exceptions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!