调用方：

    1. $response = (new \App\Library\httpclient\HttpClient())
    2.             ->withHeader('key', 'value')
    3.             ->withTimeout(3)
    4.             ->withOnFailedRetry(3, 1)
    5.             ->withResponseHeaders(['Journal-Id'])
    6.             ->get("https://xxx.com/xxx");
    8. // $response->getHTTPStatusCode();
    9. // $response->getHeaders();
    10. // $response->getBody();
    11. // $response->getErrorMessage();

    文件：App/Library/httpclient/HttpClient.php

    1. <?php
    3. namespace App\Library\httpclient;
    5. use Closure;
    6. use GuzzleHttp\Client;
    7. use GuzzleHttp\Exception\ConnectException;
    8. use GuzzleHttp\Exception\GuzzleException;
    9. use GuzzleHttp\Handler\CurlHandler;
    10. use GuzzleHttp\HandlerStack;
    11. use GuzzleHttp\Middleware;
    12. use GuzzleHttp\Psr7\Request;
    13. use GuzzleHttp\Psr7\Response;
    14. use Psr\Http\Message\ResponseInterface;
    15. use Throwable;
    17. class HttpClient
    18. {
    19.     /**
    20.      * The http request header
    21.      *
    22.      * @var array
    23.      */
    24.     protected $headers;
    26.     /**
    27.      * The http request timeout (second)
    28.      *
    29.      * The default timeout is 10s
    30.      *
    31.      * @var float
    32.      */
    33.     protected $timeout = 10;
    35.     /**
    36.      * The retry times
    37.      *
    38.      * The default retry times is 0
    39.      *
    40.      * @var int
    41.      */
    42.     protected $retryTimes = 0;
    44.     /**
    45.      *
    46.      * The retry delay (second)
    47.      *
    48.      * The default delay is 1s
    49.      *
    50.      * @var float
    51.      */
    52.     protected $retryDelay = 1;
    54.     /**
    55.      * The retry http code
    56.      *
    57.      * The default retry http code
    58.      * 408 Request Timeout RFC 7231, 6.5.7
    59.      * 423 Locked RFC 4918, 11.3
    60.      * 425 Too Early RFC 8470, 5.2.
    61.      * 429 Too Many Requests RFC 6585, 4
    62.      * 503 Service Unavailable RFC 7231, 6.6.4
    63.      * 504 Gateway Timeout RFC 7231, 6.6.5
    64.      *
    65.      * @var array
    66.      */
    67.     protected $retryHttpCode = [408, 423, 425, 429, 503, 504];
    69.     /**
    70.      * @var callable
    71.      */
    72.     protected $retryDeciderCallable;
    74.     /**
    75.      * The response headers
    76.      *
    77.      * @var string[]
    78.      */
    79.     protected $responseHeaders = ['Date'];
    81.     /**
    82.      * Configures a header item
    83.      *
    84.      * @param string $name
    85.      * @param mixed $value
    86.      *
    87.      * @return HttpClient
    88.      */
    89.     public function withHeader(string $name, $value): HttpClient
    90.     {
    91.         $this->headers[$name] = $value;
    92.         return $this;
    93.     }
    95.     /**
    96.      * Configures timeout (second)
    97.      *
    98.      * @param float $timeout
    99.      *
    100.      * @return HttpClient
    101.      */
    102.     public function withTimeout(float $timeout): HttpClient
    103.     {
    104.         $this->timeout = $timeout;
    105.         return $this;
    106.     }
    108.     /**
    109.      * Configures retry
    110.      *
    111.      * @param int $retryTimes
    112.      * @param float $retryDelay
    113.      * @param callable|null $retryDecider
    114.      * @return HttpClient
    115.      */
    116.     public function withOnFailedRetry(int $retryTimes, float $retryDelay, callable $retryDecider = null): HttpClient
    117.     {
    118.         $this->retryTimes = $retryTimes;
    119.         $this->retryDelay = $retryDelay ?? $this->retryDelay;
    121.         if ($retryDecider) {
    122.             $this->retryDeciderCallable = $retryDecider;
    123.         } else {
    124.             $this->retryDeciderCallable = function (Response $response) {
    125.                 if (in_array($response->getStatusCode(), $this->retryHttpCode)) {
    126.                     return true;
    127.                 }
    128.                 return false;
    129.             };
    130.         }
    132.         return $this;
    133.     }
    135.     /**
    136.      * Configures response headers
    137.      *
    138.      * @param array $headers
    139.      *
    140.      * @return HttpClient
    141.      */
    142.     public function withResponseHeaders(array $headers): HttpClient
    143.     {
    144.         $this->responseHeaders = array_merge($headers, $this->responseHeaders);
    145.         return $this;
    146.     }
    148.     /**
    149.      * get
    150.      *
    151.      * @param string $url
    152.      * @param array $query
    153.      *
    154.      * @return \App\Library\httpclient\Response
    155.      */
    156.     public function get(string $url, array $query = []): \App\Library\httpclient\Response
    157.     {
    158.         $guzzleOptions          = $this->guzzleHttpOptions();
    159.         $guzzleOptions['query'] = $query ?? [];
    161.         try {
    162.             $response = $this->response($this->guzzleHttpClient()->get($url, $guzzleOptions));
    163.         } catch (Throwable $throwable) {
    164.             $response = $this->response(null, $throwable->getMessage());
    165.         }
    167.         return $response;
    168.     }
    170.     /**
    171.      * postForm
    172.      *
    173.      * @param string $url
    174.      * @param array $form
    175.      *
    176.      * @return \App\Library\httpclient\Response
    177.      */
    178.     public function postForm(string $url, array $form = []): \App\Library\httpclient\Response
    179.     {
    180.         $guzzleOptions                            = $this->guzzleHttpOptions();
    181.         $guzzleOptions['form_params']             = $form ?? [];
    182.         $guzzleOptions['headers']['Content-Type'] = 'application/x-www-form-urlencoded';
    184.         try {
    185.             $response = $this->response($this->guzzleHttpClient()->post($url, $guzzleOptions));
    186.         } catch (GuzzleException $e) {
    187.             $response = $this->response(null, $e->getMessage());
    188.         }
    190.         return $response;
    191.     }
    193.     /**
    194.      * postJson
    195.      *
    196.      * @param string $url
    197.      * @param array $json
    198.      *
    199.      * @return \App\Library\httpclient\Response
    200.      */
    201.     public function postJson(string $url, array $json = []): \App\Library\httpclient\Response
    202.     {
    203.         $guzzleOptions                            = $this->guzzleHttpOptions();
    204.         $guzzleOptions['json']                    = $json ?? [];
    205.         $guzzleOptions['headers']['Content-Type'] = 'application/json';
    207.         try {
    208.             $response = $this->response($this->guzzleHttpClient()->post($url, $guzzleOptions));
    209.         } catch (GuzzleException $e) {
    210.             $response = $this->response(null, $e->getMessage());
    211.         }
    213.         return $response;
    214.     }
    216.     /**
    217.      * guzzleOptions
    218.      *
    219.      * @return array
    220.      */
    221.     private function guzzleHttpOptions(): array
    222.     {
    223.         $options['http_errors'] = false;
    224.         $options['headers']     = $this->headers ?? [];
    225.         $options['timeout']     = $this->timeout ?? 0;
    227.         return $options;
    228.     }
    230.     /**
    231.      * guzzleHttpClient
    232.      *
    233.      * @return Client
    234.      */
    235.     private function guzzleHttpClient(): Client
    236.     {
    237.         $handlerStack = HandlerStack::create(new CurlHandler());
    238.         if (!empty($this->retryTimes)) {
    239.             $handlerStack->push(Middleware::retry($this->retryDecider(), $this->retryDelay()), 'retry');
    240.         }
    242.         return new Client(['handler' => $handlerStack]);
    243.     }
    245.     /**
    246.      * retryDecider
    247.      *
    248.      * @return Closure
    249.      */
    250.     private function retryDecider(): Closure
    251.     {
    252.         return function (
    253.             $retries,
    254.             Request $request,
    255.             Response $response = null,
    256.             ConnectException $exception = null
    257.         ) {
    258.             if ($retries >= $this->retryTimes) {
    259.                 return false;
    260.             }
    262.             $shouldRetry = false;
    264.             if ($response) {
    265.                 if (($this->retryDeciderCallable)($response)) {
    266.                     $shouldRetry = true;
    267.                 }
    268.             }
    270.             return $shouldRetry;
    271.         };
    272.     }
    274.     /**
    275.      * retryDelay
    276.      *
    277.      * @return Closure
    278.      */
    279.     private function retryDelay(): Closure
    280.     {
    281.         return function () {
    282.             return 1000 * $this->retryDelay;
    283.         };
    284.     }
    286.     /**
    287.      * response
    288.      *
    289.      * @param ResponseInterface|null $guzzleResponse
    290.      * @param string $errorMessage
    291.      * @return \App\Library\httpclient\Response
    292.      */
    293.     private function response(ResponseInterface $guzzleResponse = null, string $errorMessage = ''): \App\Library\httpclient\Response
    294.     {
    295.         $responseHeaders = [];
    296.         if (!empty($guzzleResponse)) {
    297.             foreach ($this->responseHeaders as $v) {
    298.                 $responseHeaders[$v] = $guzzleResponse->getHeader($v);
    299.             }
    300.         }
    302.         return (new \App\Library\httpclient\Response(
    303.             (!empty($guzzleResponse) ? $guzzleResponse->getStatusCode() : 0),
    304.             ($responseHeaders ?? []),
    305.             (!empty($guzzleResponse) ? $guzzleResponse->getBody()->getContents() : ''),
    306.             $errorMessage
    307.         ));
    308.     }
    309. }

    文件：App/Library/httpclient/Response.php

    1. <?php
    3. namespace App\Library\httpclient;
    5. class Response
    6. {
    7.     /**
    8.      * @var int
    9.      */
    10.     protected $statusCode;
    12.     /**
    13.      * @var array
    14.      */
    15.     protected $headers;
    17.     /**
    18.      * @var string
    19.      */
    20.     protected $body;
    22.     /**
    23.      * @var string
    24.      */
    25.     protected $errorMessage;
    27.     public function __construct(int $statusCode, array $headers, string $body, string $errorMessage)
    28.     {
    29.         $this->statusCode   = $statusCode;
    30.         $this->headers      = $headers;
    31.         $this->body         = $body;
    32.         $this->errorMessage = $errorMessage;
    33.     }
    35.     public function getHTTPStatusCode(): int
    36.     {
    37.         return $this->statusCode;
    38.     }
    40.     public function getHeaders(): array
    41.     {
    42.         return $this->headers;
    43.     }
    45.     public function getBody(): string
    46.     {
    47.         return $this->body;
    48.     }
    50.     public function getErrorMessage(): string
    51.     {
    52.         return $this->errorMessage;
    53.     }
    54. }