Интеграция внешних API в PHP: практические методы и решения

$ch = curl_init('https://api.example.com/endpoint');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['Content-Type: application/json', 'Authorization: Bearer ' . $token],
CURLOPT_TIMEOUT => 30
]);

$response = curl_exec($ch);
$error = curl_error($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($error) {
// Обработка ошибок
} else {
$data = json_decode($response, true);
// Работаем с данными
}

$context = stream_context_create([
'http' => [
'method' => 'GET',
'header' => "Accept: application/json\r\n" .
"Authorization: Bearer $token\r\n"
]
]);

try {
$response = file_get_contents('https://api.example.com/endpoint', false, $context);
$data = json_decode($response, true);
// Работаем с данными
} catch (Exception $e) {
// Обработка ошибок
}

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

$client = new Client([
'base_uri' => 'https://api.example.com/',
'timeout' => 30,
'headers' => [
'Content-Type' => 'application/json',
'Authorization' => 'Bearer ' . $token
]
]);

try {
$response = $client->request('GET', 'endpoint');
$data = json_decode($response->getBody(), true);
// Работаем с данными
} catch (RequestException $e) {
// Обработка ошибок
}

function processApiResponse($response, $httpCode) {
// Проверка HTTP-статуса
if ($httpCode >= 400) {
throw new Exception("API returned error code: $httpCode");
}

// Парсинг JSON
$data = json_decode($response, true);

// Проверка на ошибки парсинга
if (json_last_error() !== JSON_ERROR_NONE) {
throw new Exception("JSON parsing error: " . json_last_error_msg());
}

// Валидация структуры ответа
if (!isset($data['status']) || $data['status'] !== 'success') {
throw new Exception("API returned unsuccessful status: " . ($data['status'] ?? 'unknown'));
}

if (!isset($data['data'])) {
throw new Exception("API response missing 'data' field");
}

return $data['data'];
}

try {
$ch = curl_init('https://api.example.com/user/123');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['Accept: application/json']
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$userData = processApiResponse($response, $httpCode);

// Теперь можно безопасно работать с валидированными данными
echo "User name: " . $userData['name'];
} catch (Exception $e) {
// Логирование ошибки и восстановление
error_log("API Error: " . $e->getMessage());
// Возможно, повторная попытка или запасной вариант
}

// Для XML ответов
$xml = simplexml_load_string($response);
if ($xml === false) {
throw new Exception("Failed to parse XML response");
}

// Доступ к данным
$username = (string)$xml->user->name;

class WeatherApiClient {
private $client;

public function __construct($apiKey) {
$this->client = new GuzzleHttp\Client([
'base_uri' => 'https://api.weather.com/',
'headers' => [
'X-API-Key' => $apiKey,
'Accept' => 'application/json'
]
]);
}

public function getWeatherByCity($city) {
try {
$response = $this->client->request('GET', 'forecast', [
'query' => ['city' => $city]
]);

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

// Трансформация данных в удобный для приложения формат
return [
'temperature' => $data['main']['temp'],
'humidity' => $data['main']['humidity'],
'description' => $data['weather'][0]['description']
];
} catch (GuzzleHttp\Exception\ClientException $e) {
if ($e->getCode() == 404) {
throw new \Exception("City not found: $city");
}
throw $e; // Re-throw other exceptions
}
}
}

function makeApiRequest($endpoint, $apiKey) {
$ch = curl_init("https://api.service.com/$endpoint");
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'X-API-Key: ' . $apiKey,
'Content-Type: application/json'
]
]);

$response = curl_exec($ch);
$error = curl_error($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 401) {
throw new Exception("Authentication failed. Invalid API key.");
}

if ($error) {
throw new Exception("cURL Error: $error");
}

return json_decode($response, true);
}

use League\OAuth2\Client\Provider\GenericProvider;

// Создаем провайдера OAuth 2.0
$provider = new GenericProvider([
'clientId' => 'your-client-id',
'clientSecret' => 'your-client-secret',
'redirectUri' => 'https://your-app.com/callback',
'urlAuthorize' => 'https://service.com/oauth/authorize',
'urlAccessToken' => 'https://service.com/oauth/token',
'urlResourceOwnerDetails' => 'https://service.com/api/user'
]);

// Получение авторизационного URL для редиректа пользователя
if (!isset($_GET['code'])) {
$authorizationUrl = $provider->getAuthorizationUrl();
$_SESSION['oauth2state'] = $provider->getState();
header('Location: '.$authorizationUrl);
exit;
}

// Проверка state для защиты от CSRF
elseif (empty($_GET['state']) || ($_GET['state'] !== $_SESSION['oauth2state'])) {
unset($_SESSION['oauth2state']);
exit('Invalid state');
}

// Обмен авторизационного кода на токен доступа
else {
try {
$token = $provider->getAccessToken('authorization_code', [
'code' => $_GET['code']
]);

// Теперь можно использовать токен для API-запросов
$request = $provider->getAuthenticatedRequest(
'GET',
'https://service.com/api/resource',
$token
);

// Отправка запроса
$client = new GuzzleHttp\Client();
$response = $client->send($request);
$data = json_decode((string) $response->getBody(), true);

// Работа с данными

} catch (\League\OAuth2\Client\Provider\Exception\IdentityProviderException $e) {
// Обработка ошибок авторизации
exit("OAuth Error: " . $e->getMessage());
}
}

class RateLimitHandler {
private $redis;
private $namespace;
private $maxRequests;
private $timeWindow;

public function __construct($redisConnection, $namespace, $maxRequests, $timeWindow) {
$this->redis = $redisConnection;
$this->namespace = $namespace;
$this->maxRequests = $maxRequests;
$this->timeWindow = $timeWindow;
}

public function canMakeRequest() {
$key = "{$this->namespace}:ratelimit:" . date('YmdHi'); // Ключ для текущей минуты
$count = $this->redis->get($key);

if ($count === false) {
// Первый запрос в этом временном окне
$this->redis->setex($key, $this->timeWindow, 1);
return true;
}

if ($count < $this->maxRequests) {
// Увеличиваем счетчик запросов
$this->redis->incr($key);
return true;
}

return false;
}

public function waitAndRequest(callable $requestFunction) {
if ($this->canMakeRequest()) {
return $requestFunction();
}

// Вычисляем, сколько нужно подождать до следующего окна
$key = "{$this->namespace}:ratelimit:" . date('YmdHi');
$ttl = $this->redis->ttl($key);

if ($ttl > 0) {
sleep($ttl + 1); // Ждем до следующего окна + 1 секунда для надежности
return $this->waitAndRequest($requestFunction);
}

// Если TTL истек, но ключ еще существует, попробуем еще раз
sleep(1);
return $this->waitAndRequest($requestFunction);
}
}

// Пример использования
$rateLimiter = new RateLimitHandler($redis, 'twitter-api', 15, 900); // 15 запросов в 15 минут

$rateLimiter->waitAndRequest(function() use ($twitterClient) {
return $twitterClient->getUserTweets('username');
});

function makeRequestWithRetries($url, $options, $maxRetries = 3, $retryDelay = 1) {
$attempts = 0;

while ($attempts < $maxRetries) {
try {
$client = new GuzzleHttp\Client();
$response = $client->request('GET', $url, $options);
return json_decode($response->getBody(), true);
} catch (GuzzleHttp\Exception\ServerException $e) {
// Ошибка сервера (5xx)
$attempts++;
if ($attempts >= $maxRetries) {
throw $e;
}

// Увеличиваем задержку с каждой попыткой (экспоненциальное откладывание)
$sleepTime = $retryDelay * pow(2, $attempts – 1);
sleep($sleepTime);
} catch (GuzzleHttp\Exception\ClientException $e) {
// Ошибка клиента (4xx) – обычно не стоит повторять
if ($e->getCode() == 429) { // Too Many Requests
$attempts++;
if ($attempts >= $maxRetries) {
throw $e;
}

// Если есть заголовок Retry-After, используем его
$response = $e->getResponse();
if ($response && $response->hasHeader('Retry-After')) {
$retryAfter = (int)$response->getHeaderLine('Retry-After');
sleep($retryAfter);
} else {
sleep(5); // Стандартная задержка
}
} else {
throw $e; // Другие клиентские ошибки не повторяем
}
} catch (Exception $e) {
// Другие ошибки – повторяем с задержкой
$attempts++;
if ($attempts >= $maxRetries) {
throw $e;
}
sleep($retryDelay);
}
}
}

use Psr\SimpleCache\CacheInterface;

class CachedApiClient {
private $client;
private $cache;
private $defaultTtl;

public function __construct(GuzzleHttp\Client $client, CacheInterface $cache, $defaultTtl = 3600) {
$this->client = $client;
$this->cache = $cache;
$this->defaultTtl = $defaultTtl;
}

public function get($endpoint, $params = [], $ttl = null) {
$ttl = $ttl ?? $this->defaultTtl;
$cacheKey = $this->generateCacheKey($endpoint, $params);

// Попытка получить из кэша
$cached = $this->cache->get($cacheKey);
if ($cached !== null) {
return $cached;
}

// Кэш не найден, делаем запрос
$response = $this->client->request('GET', $endpoint, [
'query' => $params
]);

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

// Сохраняем в кэш
$this->cache->set($cacheKey, $data, $ttl);

return $data;
}

private function generateCacheKey($endpoint, $params) {
return 'api_cache:' . md5($endpoint . json_encode($params));
}

// Метод для принудительного обновления кэша
public function refreshCache($endpoint, $params = [], $ttl = null) {
$cacheKey = $this->generateCacheKey($endpoint, $params);
$this->cache->delete($cacheKey);
return $this->get($endpoint, $params, $ttl);
}
}

// Используя Guzzle для асинхронных запросов
$client = new GuzzleHttp\Client();

$promises = [
'user' => $client->getAsync('https://api.example.com/user/1'),
'products' => $client->getAsync('https://api.example.com/products'),
'orders' => $client->getAsync('https://api.example.com/orders')
];

// Ожидаем завершения всех запросов
$results = GuzzleHttp\Promise\Utils::unwrap($promises);

// Теперь у нас есть все ответы
$userData = json_decode($results['user']->getBody(), true);
$productsData = json_decode($results['products']->getBody(), true);
$ordersData = json_decode($results['orders']->getBody(), true);

interface PaymentGatewayInterface {
public function processPayment($amount, $currency, $cardDetails);
public function refundPayment($transactionId, $amount = null);
public function getTransactionStatus($transactionId);
}

class StripeAdapter implements PaymentGatewayInterface {
private $client;

public function __construct($apiKey) {
$this->client = new \Stripe\StripeClient($apiKey);
}

public function processPayment($amount, $currency, $cardDetails) {
try {
$payment = $this->client->charges->create([
'amount' => $amount * 100, // Stripe uses cents
'currency' => $currency,
'source' => $cardDetails['token'],
'description' => $cardDetails['description'] ?? 'Payment'
]);

return [
'success' => true,
'transaction_id' => $payment->id,
'amount' => $payment->amount / 100,
'status' => $payment->status
];
} catch (\Stripe\Exception\CardException $e) {
return [
'success' => false,
'error' => $e->getMessage(),
'code' => $e->getCode()
];
}
}

public function refundPayment($transactionId, $amount = null) {
// Реализация возврата
}

public function getTransactionStatus($transactionId) {
// Реализация проверки статуса
}
}

class PayPalAdapter implements PaymentGatewayInterface {
// Аналогичная реализация для PayPal
}

// Использование
$gateway = new StripeAdapter(getenv('STRIPE_API_KEY'));
$result = $gateway->processPayment(99.99, 'USD', [
'token' => 'tok_visa',
'description' => 'Premium subscription'
]);