PHP
Het gebruik van cURL in PHP

Syntaxis

• resource curl_init ([string $ url = NULL])
• bool curl_setopt (resource $ ch, int $ option, mixed $ value)
• bool curl_setopt_array (resource $ ch, array $ opties)
• mixed curl_exec (resource $ ch)
• void curl_close (resource $ ch)

parameters

Basisgebruik (GET-aanvragen)

cURL is een hulpmiddel voor het overbrengen van gegevens met URL-syntaxis. Het ondersteunt HTTP, FTP, SCP en vele anderen (curl> = 7.19.4). Vergeet niet dat u de cURL-extensie moet installeren en inschakelen om deze te kunnen gebruiken.

// 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-aanvragen

Als u HTML uit POST-actie wilt nabootsen, kunt u cURL gebruiken.

// 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);

Multi_curl gebruiken om meerdere POST-aanvragen te doen

Soms moeten we veel POST-aanvragen doen voor een of veel verschillende eindpunten. Om dit scenario aan te pakken, kunnen we multi_curl .

Allereerst maken we hoeveel aanvragen precies nodig zijn op dezelfde manier als het eenvoudige voorbeeld en plaatsen we ze in een array.

We gebruiken de curl_multi_init en voegen elke handle eraan toe.

In dit voorbeeld gebruiken we 2 verschillende eindpunten:

//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]);
}

Vervolgens gebruiken we curl_multi_exec om de aanvragen te verzenden

//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);

Een mogelijk rendement voor dit voorbeeld kan zijn:

Het verzoek om ' http://www.example.com ' leverde 'fruit' op in 2 seconden.

Het verzoek om ' http://www.example2.com ' leverde 'zeevruchten' in 5 seconden op.

Een aanvraag maken en verzenden met een aangepaste methode

Standaard ondersteunt PHP Curl GET en POST aanvragen. Het is mogelijk om ook aangepaste verzoeken, zoals DELETE , PUT of PATCH (of zelfs niet-standaardmethoden) te verzenden met de parameter CURLOPT_CUSTOMREQUEST .

$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);

Cookies gebruiken

cURL kan cookies ontvangen als reactie op gebruik bij volgende verzoeken. Voor eenvoudige sessie cookie-verwerking in het geheugen, wordt dit bereikt met een enkele regel code:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

In gevallen waarin u cookies moet bewaren nadat de cURL-handle is vernietigd, kunt u het bestand opgeven waarin ze moeten worden opgeslagen:

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

Wanneer u ze vervolgens opnieuw wilt gebruiken, geeft u ze door als cookiebestand:

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

Houd er echter rekening mee dat deze twee stappen niet nodig zijn, tenzij u cookies tussen verschillende cURL-grepen nodig hebt. Voor de meeste gevallen is het instellen van CURLOPT_COOKIEFILE op de lege tekenreeks CURLOPT_COOKIEFILE .

Cookie-afhandeling kan bijvoorbeeld worden gebruikt om bronnen op te halen van een website waarvoor een login vereist is. Dit is meestal een procedure in twee stappen. POST eerst naar de inlogpagina.

<?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);

De tweede stap (nadat standaardfoutcontrole is uitgevoerd) is meestal een eenvoudig GET-verzoek. Het belangrijkste is om de bestaande cURL-handle opnieuw te gebruiken voor het tweede verzoek. Dit zorgt ervoor dat de cookies van het eerste antwoord automatisch worden opgenomen in het tweede verzoek.

# 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...

Dit is alleen bedoeld als een voorbeeld van cookieverwerking. In het echte leven zijn de dingen meestal ingewikkelder. Vaak moet u een eerste GET van de inlogpagina uitvoeren om een inlogtoken op te halen dat in uw POST moet worden opgenomen. Andere sites kunnen de cURL-client blokkeren op basis van de User-Agent-string, waardoor u deze moet wijzigen.

Multidimensionale gegevens en meerdere bestanden verzenden met CurlFile in één aanvraag

Laten we zeggen dat we een formulier hebben zoals hieronder. We willen de gegevens via AJAX naar onze webserver sturen en van daaruit naar een script dat op een externe server draait.

We hebben dus normale ingangen, een veld met meerdere selecties en een dropzone voor bestanden waar we meerdere bestanden kunnen uploaden.

Ervan uitgaande dat de AJAX POST-aanvraag is geslaagd, krijgen we de volgende gegevens op de PHP-site:

// print_r($_POST)

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

en de bestanden zouden er zo uit moeten zien

// 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
                )

        )

)

Tot nu toe, zo goed. Nu willen we deze gegevens en bestanden naar de externe server verzenden met behulp van cURL met de CurlFile Class

Omdat cURL alleen een eenvoudige maar geen multidimensionale array accepteert, moeten we eerst de $ _POST-array afvlakken.

Om dit te doen, zou je bijvoorbeeld deze functie kunnen gebruiken die je het volgende geeft:

// print_r($new_post_array)

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

De volgende stap is het maken van CurlFile-objecten voor de geüploade bestanden. Dit wordt gedaan door de volgende lus:

$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 is een helpfunctie van de CurlFile Class en maakt de CurlFile-objecten. We slaan elk object in de $ files array op met sleutels genaamd "upload [0]" en "upload [1]" voor onze twee bestanden.

We moeten nu de afgeplatte post-array en de file-array combineren en opslaan als $ data als volgt:

$data = $new_post_array + $files;

De laatste stap is het verzenden van het cURL-verzoek:

$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);

Aangezien $ data nu een eenvoudige (platte) array is, verzendt cURL dit POST-verzoek automatisch met Content Type: multipart / form-data

In upload.php op de externe server kun je nu de postgegevens en bestanden met $ _POST en $ _FILES ophalen zoals je normaal zou doen.

Krijg en stel aangepaste http-headers in php

De verzoekkoptekst verzenden

$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;

De aangepaste koptekst lezen

print_r(apache_request_headers());

Uitgang: -

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

We kunnen de header ook verzenden met behulp van onderstaande syntaxis: -

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