Utilisation du plug-in de requête réseau PHP par Guzzle

Lors de l'écriture du code d'arrière-plan, il est inévitable d'interagir avec d'autres interfaces tierces, comme l'envoi de modèles de messages aux comptes de service. Parfois, plus de 100 000 messages peuvent devoir être envoyés. À l’heure actuelle, vous devez envisager d’utiliser des requêtes réseau asynchrones et « multithread ».

Aujourd'hui, je recommande un plug-in Guzzle aux ingénieurs PHP.

Guzzle

Guzzle est un client HTTP PHP utilisé pour envoyer facilement des requêtes et s'intégrer dans nos services WEB.

Interface simple : construire des instructions de requête, des requêtes POST, diviser le téléchargement et le téléchargement de fichiers volumineux, utiliser des cookies HTTP, télécharger des données JSON, etc.

Envoyez des requêtes synchrones ou asynchrones en utilisant la même interface.

Utilisez l'interface PSR-7 pour demander, répondre et décharger, vous permettant d'utiliser d'autres bibliothèques de classes PSR-7 compatibles pour développer avec Guzzle.

Résume le transport HTTP sous-jacent, vous permettant de modifier l'environnement et d'autres codes, tels que : ne dépend pas fortement des flux ou sockets cURL et PHP, boucle d'événements non bloquante.

Les systèmes middleware vous permettent de créer des comportements côté client.

Installer Guzzle

Cet article combine le projet Laravel pour présenter l'utilisation de base de Guzzle, donc utiliser composer pour installer Guzzle est parfait, et le site officiel de Guzzle recommande également utiliser composer pour installer.

composer require guzzlehttp/guzzle:~6.0
// 或者
php composer.phar require guzzlehttp/guzzle:~6.0

Envoyer une simple requête POST

Accéder à des interfaces tierces, qui sont essentiellement des requêtes POST. Si vous souhaitez créer un outil de chat intelligent simple, vous pouvez utiliser l'API Turing Robot pour envoyer une requête POST afin d'obtenir le contenu de la réponse automatique. Accédez directement au code :

<?php
namespace App\Http\Controllers;
use GuzzleHttp\Client;
use Illuminate\Http\Request;
class GuzzleUseController extends Controller {
    public function tuling(Request $request) {
        $params = [
            &#39;key&#39; => &#39;*****&#39;,
            &#39;userid&#39; => &#39;yemeishu&#39;
        ];
        $params[&#39;info&#39;] = $request->input(&#39;info&#39;, &#39;你好吗&#39;);
        $client = new Client();
        $options = json_encode($params, JSON_UNESCAPED_UNICODE);
        $data = [
            &#39;body&#39; => $options,
            &#39;headers&#39; => [&#39;content-type&#39; => &#39;application/json&#39;]
        ];
        // 发送 post 请求
        $response = $client->post(&#39;http://www.tuling123.com/openapi/api&#39;, $data);
        $callback = json_decode($response->getBody()->getContents());
        return $this->output_json(&#39;200&#39;, &#39;测试图灵机器人返回结果&#39;, $callback);
    }
}

Client Guzzle->fonction de publication. est toujours très simple Oui, il vous suffit d'accéder à l'interface et aux paramètres de requête. Les paramètres incluent principalement : le corps, les en-têtes, la requête, etc. Pour plus de détails, veuillez vous référer à

http://guzzle. -cn.readthedocs.io/zh_CN /latest/quickstart.html#id8

En test :

Remarque : le robot Turing est toujours très intelligent. Il peut identifier le contexte en fonction du même identifiant utilisateur et réaliser une conversation intelligente.

Envoyer une requête POST asynchrone

Dans le développement PHP, il s'agit principalement d'une méthode de développement "orientée processus", mais lors de la demande d'une interface tierce , parfois Il n'est pas nécessaire d'attendre que l'interface tierce renvoie des résultats avant de poursuivre l'exécution. Par exemple, lorsque l'achat de l'utilisateur est réussi, nous devons envoyer une demande de publication à l'interface SMS, et la plateforme SMS enverra un message texte à l'utilisateur pour l'informer que le paiement a réussi, car ce type de « rappel » message" est une "fonction supplémentaire supplémentaire" et n'est pas obligatoire. "Savoir" si le rappel a été envoyé avec succès lorsque l'utilisateur paie.

À ce stade, vous pouvez utiliser la fonction de requête asynchrone de Guzzle et consulter directement le code :

public function sms(Request $request) {
    $code = $request->input('code');
    $client = new Client();
    $sid = '9815b4a2bb6d5******8bdb1828644f2';
    $time = '20171029173312';
    $token = 'af8728c8bc*******12019c680df4b11c';

    $sig =  strtoupper(md5($sid.$token.$time));

    $auth = trim(base64_encode($sid . ":" . $time));

    $params = ['templateSMS' => [
            'appId' => '12b43**********0091c73c0ab',
            'param' => "coding01,$code,30",
            'templateId' => '3***3',
            'to' => '17689974321'
        ]
    ];
    $options = json_encode($params, JSON_UNESCAPED_UNICODE);
    $data = [
        'query' => [
            'sig' => $sig
        ],
        'body' => $options,
        'headers' => [
            'content-type' => 'application/json',
            'Authorization' => $auth
        ]
    ];

    // 发送 post 请求
    $promise = $client->requestAsync('POST', 'https://api.ucpaas.com/2014-06-30/Accounts/9815b4a2bb6d5******8bdb1828644f2/Messages/templateSMS', $data);

    $promise->then(
        function (ResponseInterface $res) {
            Log::info('---');
            Log::info($res->getStatusCode() . "\n");
            Log::info($res->getBody()->getContents() . "\n");
        },
        function (RequestException $e) {
            Log::info('-__-');
            Log::info($e->getMessage() . "\n");
        }
    );
    $promise->wait();

    return $this->output_json('200', '测试短信 api', []);
}

Renvoyer d'abord les données de l'interface :

Puis journal de sortie :

[2017-10-29 09:53:14] local.INFO: ---  
[2017-10-29 09:53:14] local.INFO: 200
  
[2017-10-29 09:53:14] local.INFO: {"resp":{"respCode":"000000","templateSMS":{"createDate":"20171029175314","smsId":"24a93f323c9*****8608568"}}}

Le dernier message SMS reçu :

Envoyer une requête POST asynchrone multithread

「Envoyer une « requête POST asynchrone multithread » est utilisé à de nombreuses reprises. Par exemple : Double Eleven arrive bientôt. Vous pouvez effectuer certaines activités pour redonner aux anciens utilisateurs. Cela nécessite une transmission groupée d'un modèle de message aux anciens. utilisateurs pour indiquer aux utilisateurs à quelles activités participer. À l'heure actuelle, vous devez utiliser l'interface de compte officiel WeChat de demande asynchrone multithread.

Aller directement au code :

public function send($templateid, $openid, $url, $data) {
        $client = $this->bnotice->getHttp()->getClient();

        $requests = function ($open_ids) use ($templateid, $url, $data) {
            foreach($open_ids as $v){
                try {
                    yield $this->bnotice
                        ->template($templateid)
                        ->to($v)
                        ->url($url)
                        ->data($data)
                        ->request();
                } catch(Exception $e) {
                    Log::error('sendtemplate:'.$e->getMessage());
                }
            }
        };

        $pool = new Pool($client, $requests($openid), [
            'concurrency' => 16,
            'fulfilled' => function ($response, $index) {
            },
            'rejected' => function ($reason, $index) {
            },
        ]);

        $promise = $pool->promise();

        $promise->wait();
    }

La méthode de requête :

public function request($data = [])
    {
        $params = array_merge([
            'touser' => '',
            'template_id' => '',
            'url' => '',
            'topcolor' => '',
            'miniprogram' => [],
            'data' => [],
        ], $data);
        
        $required = ['touser', 'template_id'];

        foreach ($params as $key => $value) {
            if (in_array($key, $required, true) && empty($value) && empty($this->message[$key])) {
                throw new InvalidArgumentException("Attribute '$key' can not be empty!");
            }

            $params[$key] = empty($value) ? $this->message[$key] : $value;
        }

        $params['data'] = $this->formatData($params['data']);

        $this->message = $this->messageBackup;

        $options = json_encode ( $params,  JSON_UNESCAPED_UNICODE);
        $data = [
            'query' => [
                'access_token' => $this->getAccessToken()->getToken()
            ],
            'body' => $options,
            'headers' => ['content-type' => 'application/json']
        ];
        return function() use ($data) {
            return $this->getHttp()->getClient()->requestAsync('POST', $this::API_SEND_NOTICE, $data);
        };
    }

Fonction prototype de requête asynchrone multithread Guzzle, en utilisant l'objet GuzzleHttpPool

use GuzzleHttp\Pool;use GuzzleHttp\Client;use GuzzleHttp\Psr7\Request;$client = new Client();$requests = function ($total) {
    $uri = 'http://127.0.0.1:8126/guzzle-server/perf';
    for ($i = 0; $i < $total; $i++) {
        yield new Request(&#39;GET&#39;, $uri);
    }};$pool = new Pool($client, $requests(100), [
    &#39;concurrency&#39; => 5,
    &#39;fulfilled&#39; => function ($response, $index) {
        // this is delivered each successful response
    },
    &#39;rejected&#39; => function ($reason, $index) {
        // this is delivered each failed request
    },]);// Initiate the transfers and create a promise$promise = $pool->promise();// Force the pool of requests to complete.$promise->wait();

Résumé

Avec Guzzle, il est très pratique pour nous de demander des interfaces tierces simultanément et de manière asynchrone. Si le temps le permet, nous pouvons jeter un œil au code source de Guzzle pour voir comment il est implémenté.

Tutoriel recommandé : "Tutoriel PHP"

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!