PHP
Utilizzo di cURL in PHP

Sintassi

• resource curl_init ([string $ url = NULL])
• bool curl_setopt (risorsa $ ch, opzione int $, valore $ misto)
• bool curl_setopt_array (risorsa $ ch, array $ opzioni)
• misto curl_exec (risorsa $ ch)
• void curl_close (resource $ ch)

Parametri

Utilizzo di base (richieste GET)

cURL è uno strumento per il trasferimento di dati con sintassi URL. Supporta HTTP, FTP, SCP e molti altri (arricciatura> = 7.19.4). Ricorda, devi installare e abilitare l'estensione cURL per usarlo.

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

Richieste POST

Se vuoi imitare l'azione POST in formato HTML, puoi usare cURL.

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

Utilizzo di multi_curl per effettuare più richieste POST

A volte abbiamo bisogno di fare molte richieste POST a uno o più endpoint diversi. Per gestire questo scenario, possiamo usare multi_curl .

Prima di tutto, creiamo quante richieste sono necessarie esattamente nello stesso modo del semplice esempio e le inseriamo in un array.

Usiamo curl_multi_init e aggiungiamo ogni handle ad esso.

In questo esempio, utilizziamo 2 endpoint diversi:

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

Quindi, usiamo curl_multi_exec per inviare le richieste

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

Un possibile ritorno per questo esempio potrebbe essere:

La richiesta di " http://www.example.com " ha restituito "frutti" in 2 secondi.

La richiesta di " http://www.example2.com " ha restituito "frutti di mare" in 5 secondi.

Creazione e invio di una richiesta con un metodo personalizzato

Per impostazione predefinita, PHP Curl supporta POST richieste GET e POST . È anche possibile inviare richieste personalizzate, come DELETE , PUT o PATCH (o anche metodi non standard) utilizzando il parametro 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);

Utilizzo dei cookie

cURL può conservare i cookie ricevuti nelle risposte da utilizzare con le richieste successive. Per la gestione semplice dei cookie di sessione in memoria, ciò si ottiene con una singola riga di codice:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

Nei casi in cui è necessario conservare i cookie dopo che l'handle di cURL è stato distrutto, è possibile specificare il file per memorizzarli in:

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

Quindi, quando vuoi usarli di nuovo, passali come file cookie:

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

Ricorda, tuttavia, che questi due passaggi non sono necessari a meno che non sia necessario trasportare i cookie tra diversi handle di cURL. Per la maggior parte dei casi d'uso, l'impostazione di CURLOPT_COOKIEFILE sulla stringa vuota è tutto ciò che serve.

La gestione dei cookie può essere utilizzata, ad esempio, per recuperare risorse da un sito Web che richiede un accesso. Si tratta in genere di una procedura in due passaggi. Innanzitutto, POST alla pagina di accesso.

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

Il secondo passaggio (dopo il controllo degli errori standard) è solitamente una semplice richiesta GET. L'importante è riutilizzare l'handle cURL esistente per la seconda richiesta. Ciò garantisce che i cookie della prima risposta vengano automaticamente inclusi nella seconda richiesta.

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

Questo è solo inteso come un esempio di gestione dei cookie. Nella vita reale, le cose sono solitamente più complicate. Spesso è necessario eseguire un GET iniziale della pagina di accesso per estrarre un token di accesso che deve essere incluso nel POST. Altri siti potrebbero bloccare il client cURL in base alla sua stringa User-Agent, richiedendoti di cambiarlo.

Invio di dati multidimensionali e più file con CurlFile in una sola richiesta

Diciamo che abbiamo una forma come quella qui sotto. Vogliamo inviare i dati al nostro server web tramite AJAX e da lì a uno script in esecuzione su un server esterno.

Abbiamo quindi ingressi normali, un campo a selezione multipla e una dropzone di file in cui possiamo caricare più file.

Supponendo che la richiesta POST AJAX abbia avuto successo, otteniamo i seguenti dati sul sito PHP:

// print_r($_POST)

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

e i file dovrebbero assomigliare a questo

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

        )

)

Fin qui tutto bene. Ora vogliamo inviare questi dati e file al server esterno usando cURL con la classe CurlFile

Poiché cURL accetta solo un array semplice ma non multi-dimensionale, dobbiamo prima appiattire l'array $ _POST.

Per fare questo, potresti usare questa funzione per esempio che ti dà il seguente:

// print_r($new_post_array)

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

Il prossimo passo è creare oggetti CurlFile per i file caricati. Questo viene fatto dal seguente ciclo:

$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 è una funzione di supporto della classe CurlFile e crea gli oggetti CurlFile. Salviamo ogni oggetto nell'array $ files con le chiavi "upload [0]" e "upload [1]" per i nostri due file.

Ora dobbiamo combinare l'array di colonne appiattito e l'array di file e salvarlo come $ dati come questo:

$data = $new_post_array + $files;

L'ultimo passo è inviare la richiesta cURL:

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

Poiché $ data è ora un semplice array (piatto), cURL invia automaticamente questa richiesta POST con Content Type: multipart / form-data

In upload.php sul server esterno ora puoi ottenere i dati e i file dei post con $ _POST e $ _FILES come faresti normalmente.

Ottieni e imposta intestazioni http personalizzate in php

Invio dell'intestazione della richiesta

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

Leggendo l'intestazione personalizzata

print_r(apache_request_headers());

Produzione :-

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

Possiamo anche inviare l'intestazione usando la seguente sintassi: -

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