Position actuelle: Accueil> Derniers articles> Utilisez curl_share_init () dans les scripts CLI pour gérer plusieurs demandes d'API

Utilisez curl_share_init () dans les scripts CLI pour gérer plusieurs demandes d'API

M66 2025-05-18

Lors de la rédaction de scripts CLI PHP qui nécessitent un grand nombre de demandes d'API, la gestion rationnelle des ressources et l'amélioration des performances sont devenues des problèmes que les développeurs ne peuvent ignorer. En particulier dans les scénarios où plusieurs demandes HTTP sont nécessaires pour traiter simultanément, certaines fonctions avancées fournies par Curl, telles que Curl_share_Init () , peuvent nous aider à réutiliser les connexions et à partager des ressources dans une certaine mesure, améliorant ainsi l'efficacité globale d'exécution. Cet article plongera dans la façon de gérer plusieurs demandes à l'aide de curl_share_init () dans les scripts CLI.

1. Qu'est-ce que curl_share_init ()?

curl_share_init () est une fonction Curl fournie par PHP pour initialiser une poignée partagée. Cette poignée vous permet de partager le cache DNS, les séances SSL, les cookies et autres ressources entre plusieurs séances de curl.

Les options de partage prises en charge incluent:

  • Curlshopt_share :

    • Curl_lock_data_cookie : partager les données de cookie.

    • Curl_lock_data_dns : cache DNS partagé.

    • Curl_lock_data_ssl_session : partagez la session SSL.

Ces options de partage sont particulièrement utiles lors de la demande d'interfaces du même nom d'hôte ou de domaine à haute fréquence.

2. Étapes de base pour utiliser curl_share_init ()

Jetons un coup d'œil à un exemple de script CLI PHP réel, qui simule plusieurs API de demande simultanée et utilise curl_share_init () pour améliorer les performances.

 <?php

$urls = [
    "https://m66.net/api/endpoint1",
    "https://m66.net/api/endpoint2",
    "https://m66.net/api/endpoint3",
    "https://m66.net/api/endpoint4"
];

// Initialiser la poignée partagée
$sh = curl_share_init();

// Type de partage de réglage
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);

$multiHandle = curl_multi_init();
$curlHandles = [];

foreach ($urls as $url) {
    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_SHARE => $sh,
        CURLOPT_USERAGENT => "PHP-Curl-Client"
    ]);
    curl_multi_add_handle($multiHandle, $ch);
    $curlHandles[] = $ch;
}

// Effectuer des demandes multipliques
$active = null;
do {
    $mrc = curl_multi_exec($multiHandle, $active);
    curl_multi_select($multiHandle);
} while ($active > 0);

// Résultats de traitement
foreach ($curlHandles as $ch) {
    $response = curl_multi_getcontent($ch);
    $info = curl_getinfo($ch);
    echo "URL: " . $info['url'] . "\n";
    echo "HTTP Code: " . $info['http_code'] . "\n";
    echo "Response: " . substr($response, 0, 100) . "...\n\n";

    curl_multi_remove_handle($multiHandle, $ch);
    curl_close($ch);
}

// Nettoyer les ressources
curl_share_close($sh);
curl_multi_close($multiHandle);

3. Comparaison des performances et optimisation des ressources

Les avantages de l'utilisation de curl_share_init () sont particulièrement évidents dans les aspects suivants:

  1. DNS Cache Reutilisation <br> Évitez de réinscrire le nom de domaine à chaque fois que vous demandez, en économisant le temps de requête DNS.

  2. Multiplexage de session SSL <br> Pour les demandes HTTPS, le multiplexage des sessions SSL peut réduire considérablement la latence de poignée de main.

  3. Partage de cookies <br> Partagez l'état de connexion, les informations de suivi, etc. parmi plusieurs demandes pour améliorer la cohérence et l'efficacité des demandes.

  4. Optimisation d'utilisation de la mémoire <br> Les connexions multiples partagent certaines ressources, ce qui peut réduire efficacement les frais généraux de mémoire.

4. Suggestions d'utilisation

Bien que curl_share_init () soit puissant, tous les scénarios ne conviennent pas à une utilisation. Voici quelques scénarios typiques recommandés:

  • Bulk demande plusieurs interfaces sous le même nom de domaine;

  • La synchronisation d'interface haute fréquence est effectuée dans des outils CLI;

  • Les scripts de service backend, tels que les robots, la collecte de données, etc.

Dans un environnement Web (comme en mode FPM), il n'est pas recommandé d'utiliser une poignée partagée car la ressource ne peut pas être partagée en toute sécurité entre les processus simultanés, ce qui peut entraîner des conflits ou des erreurs.

Conclusion

En utilisant rationnellement curl_share_init () , les scripts CLI PHP peuvent gérer plus efficacement les tâches multi-requêtes, ce qui améliore non seulement la vitesse d'exécution, mais économise également les ressources système. Il s'agit d'une méthode d'optimisation précieuse pour les outils CLI qui nécessitent une communication fréquente avec les API externes. La maîtrise et l'application de ces technologies avancées Curl améliorera considérablement votre compétitivité lors de la création de scripts PHP haute performance.

Connexe