807 lines
14 KiB
PHP
807 lines
14 KiB
PHP
<?php
|
|
|
|
|
|
namespace Http\Client;
|
|
|
|
|
|
use Closure;
|
|
use JetBrains\PhpStorm\Pure;
|
|
use Kiri\Abstracts\Component;
|
|
use Kiri\Core\Help;
|
|
use Swoole\Coroutine\System;
|
|
|
|
defined('SPLIT_URL') or define('SPLIT_URL', '/(http[s]?:\/\/)?(([\w\-_]+\.)+\w+(:\d+)?)((\/[a-zA-Z0-9\-]+)+[\/]?(\?[a-zA-Z]+=.*)?)?/');
|
|
|
|
|
|
/**
|
|
* Class ClientAbstracts
|
|
* @package Http\Client
|
|
*/
|
|
abstract class ClientAbstracts extends Component implements IClient
|
|
{
|
|
|
|
const POST = 'post';
|
|
const UPLOAD = 'upload';
|
|
const GET = 'get';
|
|
const DELETE = 'delete';
|
|
const OPTIONS = 'options';
|
|
const HEAD = 'head';
|
|
const PUT = 'put';
|
|
|
|
private string $host = '';
|
|
|
|
private array $header = [];
|
|
|
|
private int $timeout = 0;
|
|
|
|
private ?Closure $callback = null;
|
|
private string $method = 'get';
|
|
|
|
private bool $isSSL = false;
|
|
private string $agent = '';
|
|
private string $errorCodeField = '';
|
|
private string $errorMsgField = '';
|
|
private bool $use_swoole = false;
|
|
|
|
private string $ssl_cert_file = '';
|
|
private string $ssl_key_file = '';
|
|
private string $ca = '';
|
|
private int $port = 80;
|
|
|
|
/** @var string $_message 错误信息 */
|
|
private string $_message = '';
|
|
private string $_data = '';
|
|
|
|
private int $connect_timeout = 1;
|
|
|
|
|
|
/**
|
|
* @return static
|
|
*/
|
|
#[Pure] public static function NewRequest(): static
|
|
{
|
|
return new static();
|
|
}
|
|
|
|
|
|
protected function cleanData(): void
|
|
{
|
|
$this->_data = '';
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function post(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::POST, $path, $params);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function put(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::PUT, $path, $params);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $contentType
|
|
*/
|
|
public function setContentType(string $contentType): void
|
|
{
|
|
$this->header['Content-Type'] = $contentType;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function head(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::HEAD, $path, $params);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function get(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::GET, $path, $params);
|
|
}
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function option(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::OPTIONS, $path, $params);
|
|
}
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function delete(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::DELETE, $path, $params);
|
|
}
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function options(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::OPTIONS, $path, $params);
|
|
|
|
}
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param array $params
|
|
* @return array|int|string|Result
|
|
*/
|
|
public function upload(string $path, array $params = []): array|int|string|Result
|
|
{
|
|
return $this->request(self::UPLOAD, $path, $params);
|
|
}
|
|
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getHost(): string
|
|
{
|
|
return $this->host;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
protected function getHostPort(): int
|
|
{
|
|
if (!empty($this->getPort())) {
|
|
return $this->getPort();
|
|
}
|
|
$port = 80;
|
|
if ($this->isSSL()) $port = 443;
|
|
return $port;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $host
|
|
*/
|
|
public function setHost(string $host): void
|
|
{
|
|
$this->host = $host;
|
|
if ($this->use_swoole) {
|
|
$this->host = System::gethostbyname($host);
|
|
}
|
|
$this->addHeader('Host', $host);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getHeader(): array
|
|
{
|
|
return $this->header;
|
|
}
|
|
|
|
/**
|
|
* @param array $header
|
|
*/
|
|
public function setHeader(array $header): void
|
|
{
|
|
$this->header = $header;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param array $header
|
|
* @return array
|
|
*/
|
|
public function setHeaders(array $header): array
|
|
{
|
|
if (empty($header)) {
|
|
return [];
|
|
}
|
|
foreach ($header as $key => $val) {
|
|
$this->header[$key] = $val;
|
|
}
|
|
return $this->header;
|
|
}
|
|
|
|
/**
|
|
* @param $key
|
|
* @param $value
|
|
*/
|
|
public function addHeader($key, $value): void
|
|
{
|
|
$this->header[$key] = $value;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getTimeout(): int
|
|
{
|
|
return $this->timeout;
|
|
}
|
|
|
|
/**
|
|
* @param int $value
|
|
*/
|
|
public function setTimeout(int $value): void
|
|
{
|
|
$this->timeout = $value;
|
|
}
|
|
|
|
/**
|
|
* @return Closure|null
|
|
*/
|
|
public function getCallback(): ?Closure
|
|
{
|
|
return $this->callback;
|
|
}
|
|
|
|
/**
|
|
* @param Closure|null $value
|
|
*/
|
|
public function setCallback(?Closure $value): void
|
|
{
|
|
$this->callback = $value;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getMethod(): string
|
|
{
|
|
return $this->method;
|
|
}
|
|
|
|
/**
|
|
* @param string $value
|
|
* @return static
|
|
*/
|
|
public function setMethod(string $value): static
|
|
{
|
|
$this->method = $value;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isSSL(): bool
|
|
{
|
|
return $this->isSSL;
|
|
}
|
|
|
|
/**
|
|
* @param bool $isSSL
|
|
*/
|
|
public function setIsSSL(bool $isSSL): void
|
|
{
|
|
$this->isSSL = $isSSL;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getAgent(): string
|
|
{
|
|
return $this->agent;
|
|
}
|
|
|
|
/**
|
|
* @param string $agent
|
|
*/
|
|
public function setAgent(string $agent): void
|
|
{
|
|
$this->agent = $agent;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getErrorCodeField(): string
|
|
{
|
|
return $this->errorCodeField;
|
|
}
|
|
|
|
/**
|
|
* @param string $errorCodeField
|
|
*/
|
|
public function setErrorCodeField(string $errorCodeField): void
|
|
{
|
|
$this->errorCodeField = $errorCodeField;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getErrorMsgField(): string
|
|
{
|
|
return $this->errorMsgField;
|
|
}
|
|
|
|
/**
|
|
* @param string $errorMsgField
|
|
*/
|
|
public function setErrorMsgField(string $errorMsgField): void
|
|
{
|
|
$this->errorMsgField = $errorMsgField;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isUseSwoole(): bool
|
|
{
|
|
return $this->use_swoole;
|
|
}
|
|
|
|
/**
|
|
* @param bool $use_swoole
|
|
*/
|
|
public function setUseSwoole(bool $use_swoole): void
|
|
{
|
|
$this->use_swoole = $use_swoole;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getSslCertFile(): string
|
|
{
|
|
return $this->ssl_cert_file;
|
|
}
|
|
|
|
/**
|
|
* @param string $ssl_cert_file
|
|
*/
|
|
public function setSslCertFile(string $ssl_cert_file): void
|
|
{
|
|
$this->ssl_cert_file = $ssl_cert_file;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getSslKeyFile(): string
|
|
{
|
|
return $this->ssl_key_file;
|
|
}
|
|
|
|
/**
|
|
* @param string $ssl_key_file
|
|
*/
|
|
public function setSslKeyFile(string $ssl_key_file): void
|
|
{
|
|
$this->ssl_key_file = $ssl_key_file;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getCa(): string
|
|
{
|
|
return $this->ca;
|
|
}
|
|
|
|
/**
|
|
* @param string $ssl_key_file
|
|
*/
|
|
public function setCa(string $ssl_key_file): void
|
|
{
|
|
$this->ca = $ssl_key_file;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getPort(): int
|
|
{
|
|
if ($this->isSSL()) {
|
|
return 443;
|
|
}
|
|
if (empty($this->port)) {
|
|
return 80;
|
|
}
|
|
return $this->port;
|
|
}
|
|
|
|
/**
|
|
* @param int $port
|
|
*/
|
|
public function setPort(int $port): void
|
|
{
|
|
$this->port = $port;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getMessage(): string
|
|
{
|
|
return $this->_message;
|
|
}
|
|
|
|
/**
|
|
* @param string $message
|
|
*/
|
|
public function setMessage(string $message): void
|
|
{
|
|
$this->_message = $message;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getData(): string
|
|
{
|
|
return $this->_data;
|
|
}
|
|
|
|
/**
|
|
* @param string $data
|
|
*/
|
|
public function setData(string $data): void
|
|
{
|
|
$this->_data = $data;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getConnectTimeout(): int
|
|
{
|
|
return $this->connect_timeout;
|
|
}
|
|
|
|
/**
|
|
* @param int $connect_timeout
|
|
*/
|
|
public function setConnectTimeout(int $connect_timeout): void
|
|
{
|
|
$this->connect_timeout = $connect_timeout;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $host
|
|
* @return string|string[]
|
|
*/
|
|
protected function replaceHost($host): array|string
|
|
{
|
|
if ($this->isHttp($host)) {
|
|
return str_replace('http://', '', $host);
|
|
}
|
|
if ($this->isHttps($host)) {
|
|
return str_replace('https://', '', $host);
|
|
}
|
|
return $host;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $url
|
|
* @return false|int
|
|
*/
|
|
protected function checkIsIp($url): bool|int
|
|
{
|
|
return preg_match('/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/', $url);
|
|
}
|
|
|
|
/**
|
|
* @param $url
|
|
* @return bool
|
|
*/
|
|
#[Pure] protected function isHttp($url): bool
|
|
{
|
|
return str_starts_with($url, 'http://');
|
|
}
|
|
|
|
/**
|
|
* @param $url
|
|
* @return bool
|
|
*/
|
|
#[Pure] protected function isHttps($url): bool
|
|
{
|
|
return str_starts_with($url, 'https://');
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $newData
|
|
* @return string
|
|
*/
|
|
protected function mergeParams($newData): string
|
|
{
|
|
if (!is_string($newData)) {
|
|
return $this->toRequest($newData);
|
|
}
|
|
return $newData;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $data
|
|
* @return string
|
|
*/
|
|
protected function toRequest($data): string
|
|
{
|
|
if (is_string($data)) {
|
|
return $data;
|
|
}
|
|
$contentType = 'application/x-www-form-urlencoded';
|
|
if (isset($this->header['Content-Type'])) {
|
|
$contentType = $this->header['Content-Type'];
|
|
} else if (isset($this->header['content-type'])) {
|
|
$contentType = $this->header['content-type'];
|
|
}
|
|
if (str_contains($contentType, 'json')) {
|
|
return Help::toJson($data);
|
|
} else if (str_contains($contentType, 'xml')) {
|
|
return Help::toXml($data);
|
|
} else {
|
|
return http_build_query($data);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $data
|
|
* @param $body
|
|
* @return array|string|null
|
|
*/
|
|
protected function resolve($data, $body): array|string|null
|
|
{
|
|
if (is_array($body)) {
|
|
return $body;
|
|
}
|
|
$type = $data['content-type'] ?? $data['Content-Type'] ?? 'text/html';
|
|
if (str_contains($type, 'text/html')) {
|
|
return $body;
|
|
} else if (str_contains($type, 'json')) {
|
|
return json_decode($body, true);
|
|
} else if (str_contains($type, 'xml')) {
|
|
return Help::xmlToArray($body);
|
|
} else if (str_contains($type, 'plain')) {
|
|
return Help::toArray($body);
|
|
}
|
|
return $body;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $body
|
|
* @param $_data
|
|
* @param array $header
|
|
* @param int $statusCode
|
|
* @return mixed 构建返回体
|
|
* 构建返回体
|
|
*/
|
|
protected function structure($body, $_data, $header = [], $statusCode = 200): mixed
|
|
{
|
|
if ($this->callback instanceof Closure) {
|
|
$result = call_user_func($this->callback, $body, $_data, $header);
|
|
} else {
|
|
$result = $this->parseResult($body, $header, $statusCode);
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $body
|
|
* @param $header
|
|
* @param $statusCode
|
|
* @return Result
|
|
*/
|
|
private function parseResult($body, $header, $statusCode): Result
|
|
{
|
|
if (is_string($body)) {
|
|
$result['code'] = 0;
|
|
$result['message'] = '';
|
|
} else {
|
|
$result['code'] = $body[$this->errorCodeField] ?? 0;
|
|
$result['message'] = $this->searchMessageByData($body);
|
|
}
|
|
$result['data'] = $body;
|
|
$result['header'] = $header;
|
|
$result['httpStatus'] = $statusCode;
|
|
return new Result($result);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $body
|
|
* @return mixed
|
|
*/
|
|
protected function searchMessageByData($body): mixed
|
|
{
|
|
$parent = [];
|
|
if (empty($this->errorMsgField)) {
|
|
return 'system success.';
|
|
}
|
|
$explode = explode('.', $this->errorMsgField);
|
|
if (!isset($body[$explode[0]])) {
|
|
return 'system success.';
|
|
}
|
|
foreach ($explode as $item) {
|
|
if (empty($item)) {
|
|
continue;
|
|
}
|
|
if (empty($parent)) {
|
|
$parent = $body[$item];
|
|
continue;
|
|
}
|
|
if (is_string($parent) || !isset($parent[$item])) {
|
|
break;
|
|
}
|
|
$parent = $parent[$item];
|
|
}
|
|
return !empty($parent) ? $parent : 'system success.';
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
* check isPost Request
|
|
*/
|
|
#[Pure] public function isPost(): bool
|
|
{
|
|
return strtolower($this->method) === self::POST;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
* check isPost Request
|
|
*/
|
|
#[Pure] public function isUpload(): bool
|
|
{
|
|
return strtolower($this->method) === self::UPLOAD;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*
|
|
* check isGet Request
|
|
*/
|
|
#[Pure] public function isGet(): bool
|
|
{
|
|
return strtolower($this->method) === self::GET;
|
|
}
|
|
|
|
/**
|
|
* @param $arr
|
|
*
|
|
* @return array|string
|
|
* 将请求参数进行编码
|
|
*/
|
|
#[Pure] protected function paramEncode($arr): array|string
|
|
{
|
|
if (!is_array($arr)) {
|
|
return $arr;
|
|
}
|
|
$_tmp = [];
|
|
foreach ($arr as $Key => $val) {
|
|
$_tmp[$Key] = $val;
|
|
}
|
|
if ($this->isGet()) {
|
|
return http_build_query($_tmp);
|
|
}
|
|
return $_tmp;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $string
|
|
* @return array
|
|
*/
|
|
protected function matchHost(string $string): array
|
|
{
|
|
if (($parse = isUrl($string, true)) === false) {
|
|
return $this->defaultString($string);
|
|
}
|
|
[$isHttps, $domain, $port, $path] = $parse;
|
|
if (str_contains($domain, ':' . $port)) {
|
|
$domain = str_replace(':' . $port, '', $domain);
|
|
}
|
|
$this->port = $isHttps ? 443 : $this->port;
|
|
if (isIp($domain)) {
|
|
$this->host = $domain;
|
|
} else if ($this->isUseSwoole()) {
|
|
$this->host = System::gethostbyname($domain) ?? $domain;
|
|
} else {
|
|
$this->host = $domain;
|
|
}
|
|
$this->header['Host'] = $domain;
|
|
if (!str_starts_with($path, '/')) {
|
|
$path = '/' . $path;
|
|
}
|
|
return [$this->host, $isHttps, $path];
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $string
|
|
* @return array
|
|
*/
|
|
private function defaultString($string): array
|
|
{
|
|
$host = $this->getHost();
|
|
if ($string == '/') {
|
|
$string = '';
|
|
} else if (strpos($string, '/') !== 0) {
|
|
$string = '/' . $string;
|
|
}
|
|
return [$host, $this->isSSL(), $string];
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $path
|
|
* @param $params
|
|
* @return string
|
|
*/
|
|
#[Pure] protected function joinGetParams($path, $params): string
|
|
{
|
|
if (empty($params)) {
|
|
return $path;
|
|
}
|
|
if (!is_string($params)) {
|
|
$params = http_build_query($params);
|
|
}
|
|
if (str_contains($path, '?')) {
|
|
[$path, $getParams] = explode('?', $path);
|
|
}
|
|
if (!isset($getParams) || empty($getParams)) {
|
|
return $path . '?' . $params;
|
|
}
|
|
return $path . '?' . $params . '&' . $getParams;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $code
|
|
* @param $message
|
|
* @param $data
|
|
* @param $header
|
|
* @return Result
|
|
*/
|
|
protected function fail($code, $message, $data = [], $header = []): Result
|
|
{
|
|
return new Result([
|
|
'code' => $code,
|
|
'message' => $message,
|
|
'data' => $data,
|
|
'header' => $header,
|
|
]);
|
|
}
|
|
|
|
|
|
}
|