Français
Français
Dans PHP, Curl_share_Init est une fonction très utile. Il permet à plusieurs demandes de curl de partager les mêmes ressources, telles que des sessions, des cookies ou des fichiers, etc., ce qui peut réduire efficacement les frais généraux des demandes répétées de ressources et améliorer les performances. Dans les applications réelles, nous devrons peut-être gérer, configurer ou intercepter de manière centralisée plusieurs demandes, et le middleware Interceptor est particulièrement important.
Cet article expliquera comment construire un intercepteur middleware qui prend en charge Curl_share_init et vous aide à mieux comprendre ce processus avec des exemples pratiques.
Un intercepteur middleware est un composant utilisé pour intercepter les demandes et les réponses, qui peuvent effectuer certaines opérations avant que la demande entre et après le départ de la réponse. En règle générale, ils sont utilisés pour enregistrer les journaux, gérer l'authentification, le contrôle du cache, l'ajout d'en-tête de demande, le formatage de réponse, etc.
Dans notre cas, l'intercepteur effectuerait un traitement supplémentaire avant ou après la demande de Curl. Pour le middleware qui prend en charge Curl_share_Init , notre objectif est de nous assurer qu'une ressource de session peut être partagée sur plusieurs demandes de curl, évitant ainsi l'initialisation d'une nouvelle session Curl à chaque fois.
Nous pouvons créer une classe middleware spécialement utilisée pour gérer toutes les interceptions de demande de boucles. Cette classe fournira des fonctions d'initialisation et de gestion des ressources de base.
class CurlMiddleware
{
private $shareHandle;
public function __construct()
{
// Initialiser les ressources partagées
$this->shareHandle = curl_share_init();
}
public function __destruct()
{
// Détruiser les ressources partagées
if ($this->shareHandle) {
curl_share_close($this->shareHandle);
}
}
public function handleRequest($url, $options = [])
{
// installation cURL Partager des ressources
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_SHARE, $this->shareHandle);
// installation其他 cURL Options
curl_setopt_array($ch, $options);
// Exécuter une demande
$response = curl_exec($ch);
if (curl_errno($ch)) {
// Gestion des erreurs
echo 'Curl error: ' . curl_error($ch);
}
curl_close($ch);
return $response;
}
}
Dans le code ci-dessus, nous avons implémenté une classe Curlmiddleware de base. Pour en faire un middleware, nous pouvons contrôler la demande et la réponse en ajoutant une logique d'interception.
Nous pouvons ajouter des pré et post-opérations pour intercepter et modifier les demandes ou les réponses dans la méthode Handlerequest .
class CurlMiddleware
{
private $shareHandle;
public function __construct()
{
// Initialiser les ressources partagées
$this->shareHandle = curl_share_init();
}
public function __destruct()
{
// Détruiser les ressources partagées
if ($this->shareHandle) {
curl_share_close($this->shareHandle);
}
}
public function beforeRequest($url, $options)
{
// Actions effectuées avant d'envoyer une demande（Par exemple, modifier URL 或installation额外的Options）
$parsedUrl = parse_url($url);
$url = 'https://m66.net' . $parsedUrl['path']; // Remplacer le nom de domaine
return $url;
}
public function afterRequest($response)
{
// Actions effectuées après la demande（Par exemple, journalisation、Formatage de réponse）
// Ici, nous pouvons apporter des modifications à la réponse ou enregistrer le journal
return $response;
}
public function handleRequest($url, $options = [])
{
// Préopération：Réviser URL 或者其他Options
$url = $this->beforeRequest($url, $options);
// installation cURL Partager des ressources
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_SHARE, $this->shareHandle);
// installation其他 cURL Options
curl_setopt_array($ch, $options);
// Exécuter une demande
$response = curl_exec($ch);
if (curl_errno($ch)) {
// Gestion des erreurs
echo 'Curl error: ' . curl_error($ch);
}
curl_close($ch);
// Post-opération：Réponse de traitement
return $this->afterRequest($response);
}
}
Maintenant, la classe Curlmiddleware peut exécuter une logique d'interception avant et après chaque demande. En usage réel, nous n'avons qu'à créer une instance middleware et à appeler la méthode HandleRequest pour faire la demande.
$middleware = new CurlMiddleware();
$options = [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_FOLLOWLOCATION => true
];
// demander URL
$url = 'https://example.com/api/data';
// 发送demander
$response = $middleware->handleRequest($url, $options);
// Imprimer les résultats de la réponse
echo $response;
Puisque nous utilisons Curl_share_Init , plusieurs demandes Curl partageront les mêmes ressources (telles que les cookies, les informations de session, etc.). Ceci est très utile pour les situations où l'État doit être partagé sur plusieurs demandes. Dans notre middleware, toutes les demandes de curl utilisent la même poignée partagée, garantissant qu'ils partagent les mêmes données de session.
Il convient de noter que dans certains cas, il peut être nécessaire de configurer le comportement de curl_share_init , en particulier lorsque plusieurs demandes nécessitent un accès synchrone aux ressources partagées.
Cet article montre comment construire un intercepteur middleware qui prend en charge Curl_share_init . Grâce à ces middleware, nous pouvons partager les ressources de session et intercepter les demandes et les réponses lorsque les demandes de boucle sont lancées plusieurs fois, afin d'effectuer la journalisation, le traitement des erreurs, la modification de l'URL et d'autres opérations.
