PHP
CURL in PHP verwenden

Syntax

• resource curl_init ([string $ url = NULL])
• bool curl_setopt (resource $ ch, int $ -Option, gemischter $ -Wert)
• bool curl_setopt_array (Ressource $ ch, Array $ options)
• gemischte curl_exec (Ressource $ ch)
• curl_close ungültig machen (Ressource $ ch)

Parameter

Grundnutzung (GET-Anfragen)

cURL ist ein Tool zum Übertragen von Daten mit URL-Syntax. Es unterstützt HTTP, FTP, SCP und viele andere (curl> = 7.19.4). Denken Sie daran, dass Sie die cURL-Erweiterung installieren und aktivieren müssen, um sie verwenden zu können.

// a little script check is the cURL extension loaded or not
if(!extension_loaded("curl")) {
    die("cURL extension not loaded! Quit Now.");
}

// Actual script start

// create a new cURL resource
// $curl is the handle of the resource
$curl = curl_init();

// set the URL and other options
curl_setopt($curl, CURLOPT_URL, "http://www.example.com");

// execute and pass the result to browser
curl_exec($curl);

// close the cURL resource
curl_close($curl);

POST-Anfragen

Wenn Sie die POST-Aktion des HTML-Formulars nachahmen möchten, können Sie cURL verwenden.

// POST data in array
$post = [
    'a' => 'apple',
    'b' => 'banana'
];

// Create a new cURL resource with URL to POST
$ch = curl_init('http://www.example.com');

// We set parameter CURLOPT_RETURNTRANSFER to read output
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Let's pass POST data
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);

// We execute our request, and get output in a $response variable
$response = curl_exec($ch);

// Close the connection
curl_close($ch);

Verwenden von multi_curl zum Erstellen mehrerer POST-Anforderungen

Manchmal müssen wir viele POST-Anforderungen an einen oder mehrere Endpunkte stellen. Um mit diesem Szenario multi_curl werden, können wir multi_curl .

Zunächst erstellen wir wie viele Anfragen genau wie im einfachen Beispiel und setzen sie in ein Array.

Wir verwenden den curl_multi_init und fügen jeden Ziehpunkt hinzu.

In diesem Beispiel verwenden wir zwei verschiedene Endpunkte:

//array of data to POST
$request_contents = array();
//array of URLs
$urls = array();
//array of cURL handles
$chs = array();

//first POST content
$request_contents[] = [
    'a' => 'apple',
    'b' => 'banana'
];
//second POST content
$request_contents[] = [
    'a' => 'fish',
    'b' => 'shrimp'
];
//set the urls
$urls[] = 'http://www.example.com';
$urls[] = 'http://www.example2.com';

//create the array of cURL handles and add to a multi_curl
$mh = curl_multi_init();
foreach ($urls as $key => $url) {
    $chs[$key] = curl_init($url);
    curl_setopt($chs[$key], CURLOPT_RETURNTRANSFER, true);
    curl_setopt($chs[$key], CURLOPT_POST, true);
    curl_setopt($chs[$key], CURLOPT_POSTFIELDS, $request_contents[$key]);

    curl_multi_add_handle($mh, $chs[$key]);
}

Dann verwenden wir curl_multi_exec, um die Anfragen zu senden

//running the requests
$running = null;
do {
  curl_multi_exec($mh, $running);
} while ($running);

//getting the responses
foreach(array_keys($chs) as $key){
    $error = curl_error($chs[$key]);
    $last_effective_URL = curl_getinfo($chs[$key], CURLINFO_EFFECTIVE_URL);
    $time = curl_getinfo($chs[$key], CURLINFO_TOTAL_TIME);
    $response = curl_multi_getcontent($chs[$key]);  // get results
    if (!empty($error)) {
      echo "The request $key return a error: $error" . "\n";
    }
    else {
      echo "The request to '$last_effective_URL' returned '$response' in $time seconds." . "\n";
    }

    curl_multi_remove_handle($mh, $chs[$key]);
}

// close current handler
curl_multi_close($mh);

Eine mögliche Rückgabe für dieses Beispiel könnte sein:

Die Anfrage an ' http://www.example.com ' gab 'Früchte' in 2 Sekunden zurück.

Die Anfrage an " http://www.example2.com " gab innerhalb von 5 Sekunden "Meeresfrüchte" zurück.

Erstellen und Senden einer Anfrage mit einer benutzerdefinierten Methode

Standardmäßig unterstützt PHP Curl GET und POST Anforderungen. Mit dem Parameter CURLOPT_CUSTOMREQUEST können auch benutzerdefinierte Anforderungen wie DELETE , PUT oder PATCH (oder auch PATCH Methoden) CURLOPT_CUSTOMREQUEST werden.

$method = 'DELETE'; // Create a DELETE request

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
$content = curl_exec($ch);
curl_close($ch);

Verwendung von Cookies

cURL kann Cookies in Antworten für nachfolgende Anfragen erhalten lassen. Für das einfache Handling von Session-Cookies im Speicher wird dies mit einer einzelnen Codezeile erreicht:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

Wenn Sie nach dem Löschen des cURL-Handles Cookies aufbewahren müssen, können Sie die Datei angeben, in der sie gespeichert werden sollen:

curl_setopt($ch, CURLOPT_COOKIEJAR, "/tmp/cookies.txt");

Wenn Sie sie dann erneut verwenden möchten, übergeben Sie sie als Cookie-Datei:

curl_setopt($ch, CURLOPT_COOKIEFILE, "/tmp/cookies.txt");

Beachten Sie jedoch, dass diese beiden Schritte nicht erforderlich sind, es sei denn, Sie müssen Cookies zwischen verschiedenen cURL-Handles tragen. Für die meisten Anwendungsfälle reicht es aus, CURLOPT_COOKIEFILE auf die leere Zeichenfolge zu setzen.

Die Cookie-Behandlung kann beispielsweise verwendet werden, um Ressourcen von einer Website abzurufen, für die ein Login erforderlich ist. Dies ist normalerweise ein zweistufiger Vorgang. Zuerst POST auf die Login-Seite.

<?php

# create a cURL handle
$ch  = curl_init();

# set the URL (this could also be passed to curl_init() if desired)
curl_setopt($ch, CURLOPT_URL, "https://www.example.com/login.php");

# set the HTTP method to POST
curl_setopt($ch, CURLOPT_POST, true);

# setting this option to an empty string enables cookie handling
# but does not load cookies from a file
curl_setopt($ch, CURLOPT_COOKIEFILE, "");

# set the values to be sent
curl_setopt($ch, CURLOPT_POSTFIELDS, array(
    "username"=>"joe_bloggs",
    "password"=>"$up3r_$3cr3t",
));

# return the response body
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

# send the request
$result = curl_exec($ch);

Der zweite Schritt (nach der Standardfehlerprüfung) ist normalerweise eine einfache GET-Anforderung. Das Wichtigste ist, das vorhandene cURL-Handle für die zweite Anfrage erneut zu verwenden. Dadurch wird sichergestellt, dass die Cookies der ersten Antwort automatisch in die zweite Anfrage aufgenommen werden.

# we are not calling curl_init()

# simply change the URL
curl_setopt($ch, CURLOPT_URL, "https://www.example.com/show_me_the_foo.php");

# change the method back to GET
curl_setopt($ch, CURLOPT_HTTPGET, true);

# send the request
$result = curl_exec($ch);

# finished with cURL
curl_close($ch);

# do stuff with $result...

Dies ist nur als Beispiel für die Cookie-Behandlung gedacht. Im wirklichen Leben sind die Dinge normalerweise komplizierter. Häufig müssen Sie ein erstes GET der Anmeldeseite durchführen, um ein Anmeldetoken abzurufen, das in Ihrem POST enthalten sein muss. Andere Sites blockieren möglicherweise den cURL-Client basierend auf seiner User-Agent-Zeichenfolge, sodass Sie diese ändern müssen.

Senden Sie mehrdimensionale Daten und mehrere Dateien mit CurlFile in einer Anfrage

Nehmen wir an, wir haben ein Formular wie das folgende. Wir möchten die Daten über AJAX an unseren Webserver senden und von dort an ein Skript, das auf einem externen Server ausgeführt wird.

Wir haben also normale Eingaben, ein Mehrfachauswahlfeld und eine Datei-Dropzone, in die wir mehrere Dateien hochladen können.

Wenn die AJAX POST-Anfrage erfolgreich war, werden folgende Daten auf der PHP-Site abgerufen:

// print_r($_POST)

Array
(
    [first_name] => John
    [last_name] => Doe
    [activities] => Array
        (
            [0] => soccer
            [1] => hiking
        )
)

und die Dateien sollten so aussehen

// print_r($_FILES)

Array
(
    [upload] => Array
        (
            [name] => Array
                (
                    [0] => my_photo.jpg
                    [1] => my_life.pdf
                )

            [type] => Array
                (
                    [0] => image/jpg
                    [1] => application/pdf
                )

            [tmp_name] => Array
                (
                    [0] => /tmp/phpW5spji
                    [1] => /tmp/phpWgnUeY
                )

            [error] => Array
                (
                    [0] => 0
                    [1] => 0
                )

            [size] => Array
                (
                    [0] => 647548
                    [1] => 643223
                )

        )

)

So weit, ist es gut. Nun möchten wir diese Daten und Dateien mit cURL mit der CurlFile-Klasse an den externen Server senden

Da cURL nur ein einfaches, aber kein mehrdimensionales Array akzeptiert, müssen wir zuerst das $ _POST-Array abflachen.

Dazu können Sie beispielsweise diese Funktion verwenden, die Ihnen Folgendes gibt:

// print_r($new_post_array)

Array
(
    [first_name] => John
    [last_name] => Doe
    [activities[0]] => soccer
    [activities[1]] => hiking
)

Der nächste Schritt ist das Erstellen von CurlFile-Objekten für die hochgeladenen Dateien. Dies geschieht durch die folgende Schleife:

$files = array();

foreach ($_FILES["upload"]["error"] as $key => $error) {
    if ($error == UPLOAD_ERR_OK) {

        $files["upload[$key]"] = curl_file_create(
            $_FILES['upload']['tmp_name'][$key],
            $_FILES['upload']['type'][$key],
            $_FILES['upload']['name'][$key]
        );
    }
}

curl_file_create ist eine Hilfsfunktion der CurlFile-Klasse und erstellt die CurlFile-Objekte. Wir speichern jedes Objekt im $ files-Array mit den Schlüsseln "upload [0]" und "upload [1]" für unsere beiden Dateien.

Wir müssen nun das abgeflachte Post-Array und das File-Array zusammenfassen und als $ data wie folgt speichern:

$data = $new_post_array + $files;

Der letzte Schritt ist das Senden der cURL-Anfrage:

$ch = curl_init();

curl_setopt_array($ch, array(
    CURLOPT_POST => 1,
    CURLOPT_URL => "https://api.externalserver.com/upload.php",
    CURLOPT_RETURNTRANSFER => 1,
    CURLINFO_HEADER_OUT => 1,
    CURLOPT_POSTFIELDS => $data
));

$result = curl_exec($ch);

curl_close ($ch);

Da $ data jetzt ein einfaches (flaches) Array ist, sendet cURL diese POST-Anforderung automatisch mit dem Inhaltstyp Multipart / Form-Daten

In upload.php auf dem externen Server können Sie wie gewohnt die Postdaten und Dateien mit $ _POST und $ _FILES abrufen.

Erhalte und setze benutzerdefinierte http-Header in PHP

Senden der Anforderungsheader

$uri = 'http://localhost/http.php';
$ch = curl_init($uri);
curl_setopt_array($ch, array(
    CURLOPT_HTTPHEADER  => array('X-User: admin', 'X-Authorization: 123456'),
    CURLOPT_RETURNTRANSFER  =>true,
    CURLOPT_VERBOSE     => 1
));
$out = curl_exec($ch);
curl_close($ch);
// echo response output
echo $out;

Den benutzerdefinierten Header lesen

print_r(apache_request_headers());

Ausgabe :-

Array
(
    [Host] => localhost
    [Accept] => */*
    [X-User] => admin
    [X-Authorization] => 123456
    [Content-Length] => 9
    [Content-Type] => application/x-www-form-urlencoded
)

Wir können den Header auch mit der folgenden Syntax senden: -

curl --header "X-MyHeader: 123" www.google.com