Kurz über die Lösungsmethoden für das Backend- und API-Access Timeout in PHP

[HTTP-Anbindung]

Wir haben viele Möglichkeiten, HTTP zu erreichen, hauptsächlich: curl, socket, file_get_contents() und andere Methoden.

Wenn der Server des anderen immer nicht reagiert, dann haben wir Pech, es ist leicht, den gesamten Server zu killen, daher muss auch bei der Anbindung an HTTP das Problem der Zeitüberschreitung berücksichtigt werden.

[CURL-Anbindung an HTTP]

CURL ist eine der häufig verwendeten, zuverlässigen Bibliotheken zur Anbindung an HTTP-Protokoll-Interfaces, die eine hohe Leistung und einige Funktionen zur Unterstützung von Mehrverbindung haben.

CURL:

curl_setopt($ch, opt) kann einige Timeout-Einstellungen festlegen, darunter hauptsächlich:

*(Wichtig) CURLOPT_TIMEOUT setzt die längste zulässige Sekundenzeit für cURL.

*(Wichtig) CURLOPT_TIMEOUT_MS setzt die längste zulässige Millisekundenzeit für cURL. (In cURL 7.16.2wurde in PHP 5.2.3verfügbar. )

CURLOPT_CONNECTTIMEOUT wartet vor dem Verbindungsaufbau, in Millisekunden. Wenn auf 0 gesetzt, wird unendlich gewartet.

CURLOPT_CONNECTTIMEOUT_MS versucht, die Verbindung zu warten, in Millisekunden. Wenn auf 0 gesetzt, wird unendlich gewartet. In cURL 7.16.2wurde in PHP 5.2.3verfügbar.

CURLOPT_DNS_CACHE_TIMEOUT speichert die DNS-Informationen im Speicher, die Standardzeit beträgt120 Sekunden.

curl Standard-Sekunden-Timeout:

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL,$url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

curl_setopt($ch, CURLOPT_TIMEOUT, 60);　　 //Es reicht aus, eine Sekundenanzahl einzustellen

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

curl_setopt($ch, CURLOPT_USERAGENT, $defined_vars['HTTP_USER_AGENT']);

curl verwendet die Sekunden-Timeout-Einstellungen:

curl_setopt($ch, CURLOPT_TIMEOUT, 60);

Wenn curl einen Millisekunden-Timeout benötigt, muss hinzugefügt werden:

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

oder:

curl_setopt($ch, CURLOPT_NOSIGNAL, true); unterstützt die Millisekunden-Timeout-Einstellungen

Ein Beispiel für einen curl-Millisekunden-Timeout:

<?php
if (!isset($_GET['foo'])) {
// Client
    $ch = curl_init('http://example.com/');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_NOSIGNAL, 1);  
//Hinweis: Der Millisekunden-Timeout muss unbedingt eingestellt werden
    curl_setopt($ch, CURLOPT_TIMEOUT_MS, 200); 
//Zeitüherablauf in Millisekunden, cURL 7.16.2wurde in PHP 5.2.3Verwendung ist möglich
    $data = curl_exec($ch);
    $curl_errno = curl_errno($ch);
    $curl_error = curl_error($ch);
    curl_close($ch);
    if ($curl_errno > 0) {
        echo "cURL Fehler ($curl_errno): $curl_error\n";
    } else {
        echo "Daten empfangen: $data\n";
    }
} else {
// Server
    sleep(10);
    echo "Erledigt.";
}
?>

Andere nützliche Tipps:

1. Nach Erfahrung ist: cURL Version >= libcurl/7.21.0 Version, Millisekunden-Zeitüherablauf ist unbedingt wirksam, bitte beachten Sie.

2. curl_multi hat auch Probleme mit Millisekunden-Zeitüherablauf. Einmaliger Zugriff unterstüt Millisekunden-Zeitüherablauf, curl_multi parallel mehrere Aufrufe nicht genau

[Stream-Verarbeitungsmethode zum Zugriff auf HTTP]

Neben curl verwenden wir oft selbst fsockopen oder Datei-Bearbeitungsfunktionen, um HTTP-Protokolle zu verarbeiten, daher ist die Verarbeitung des Zeitüherablaufs in diesem Bereich auch erforderlich.

Der Zeitüherablauf für die Verbindung kann direkt eingestellt werden, aber der Zeitüherablauf für den Stream-Lesen muss separiert behandelt werden.

Schreiben Sie selbst Code zur Verarbeitung:

$intUSGone = ($tmCurrent['sec'] - $tmStart['sec']) * 10
+ ($tmCurrent['usec'] - $tmStart['usec']);
if ($intUSGone > $this->_intReadTimeoutUS) {
return false;
}

oder verwenden Sie die integrierten Stream-Bearbeitungsfunktionen stream_set_timeout() und stream_get_meta_data() zur Verarbeitung:

<?php 
// Zeitüherablauf in Sekunden 
$timeout = 5; 
$fp = fsockopen("example.com", 80, $errno, $errstr, $timeout); 
if ($fp) { 
    fwrite($fp, "GET"); / HTTP/1.0\r\n"); 
    fwrite($fp, "Host: example.com\r\n"); 
    fwrite($fp, "Verbindung: Schließen\r\n\r\n"); 
    stream_set_blocking($fp, true);  
//Wichtig, auf nicht-blockierenden Modus setzen
    stream_set_timeout($fp,$timeout);  
//Zeitüberschreitung einstellen
    $info = stream_get_meta_data($fp); 
    while ((!feof($fp)) && (!$info['timed_out'])) { 
        $data .= fgets($fp, 4096); 
        $info = stream_get_meta_data($fp); 
        ob_flush; 
        flush(); 
    } 
    if ($info['timed_out']) { 
        echo "Verbindung Zeitüberschreitung!"; 
    } else { 
        echo $data; 
    } 
}

file_get_contents Zeitzu überschreitung:

<?php
$timeout = array(
  'http' => array(
    'timeout' => 5 
//Setzen Sie eine Zeitüberschreitungsdauer, die in Sekunden angegeben wird
  )
);
$ctx = stream_context_create($timeout);
$text = file_get_contents("http://example.com/", 0, $ctx);
?>

fopen Zeitzu überschreitung:

<?php
$timeout = array(
  'http' => array(
    'timeout' => 5 
//Setzen Sie eine Zeitüberschreitungsdauer, die in Sekunden angegeben wird
  )
);
$ctx = stream_context_create($timeout);
if ($fp = fopen("http://example.com/", "r", false, $ctx)) {
 while( $c = fread($fp, 8192)) {
  echo $c;
 }
 fclose($fp);
}
?>

Das ist alles, was der Autor Ihnen hier als kurze Einführung in die Lösungsmöglichkeiten für das Ueberlauf des Backend- und API-Zugriffs in PHP vorgestellt hat. Ich hoffe, dass alle viele Unterstützung für die Anleitung rufen.