PHP
Med hjälp av cURL i PHP

Syntax

• resurs curl_init ([string $ url = NULL])
• bool curl_setopt (resurs $ ch, int $ alternativ, blandat $ värde)
• bool curl_setopt_array (resurs $ ch, alternativ $ array)
• blandad curl_exec (resurs $ ch)
• void curl_close (resurs $ ch)

parametrar

Grundläggande användning (GET-förfrågningar)

cURL är ett verktyg för att överföra data med URL-syntax. Det stöder HTTP, FTP, SCP och många andra (curl> = 7.19.4). Kom ihåg att du måste installera och aktivera cURL-förlängningen för att använda den.

// 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-förfrågningar

Om du vill efterlikna HTML-POST-åtgärd kan du använda 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);

Använda multi_curl för att göra flera POST-förfrågningar

Ibland måste vi göra många POST-förfrågningar till en eller många olika slutpunkter. För att hantera detta scenario kan vi använda multi_curl .

Först skapar vi hur många förfrågningar som behövs exakt på samma sätt som det enkla exemplet och sätter dem i en matris.

Vi använder curl_multi_init och lägger till varje handtag.

I det här exemplet använder vi två olika slutpunkter:

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

Sedan använder vi curl_multi_exec för att skicka förfrågningarna

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

En möjlig avkastning för detta exempel kan vara:

Begäran till ' http://www.example.com ' returnerade 'frukter' på 2 sekunder.

Begäran till " http://www.example2.com " returnerade "seafood" på 5 sekunder.

Skapa och skicka en begäran med en anpassad metod

Som standard stöder PHP Curl GET och POST förfrågningar. Det är möjligt att också skicka anpassade förfrågningar, som DELETE , PUT eller PATCH (eller till och med icke-standardmetoder) med parametern 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);

Använda kakor

cURL kan hålla cookies mottagna i svar för användning med efterföljande förfrågningar. För enkel hantering av sessionskakor i minnet uppnås detta med en enda kodrad:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

I de fall du måste hålla cookies efter att CURL-handtaget förstörts, kan du ange filen för att lagra dem i:

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

Sedan, när du vill använda dem igen, skicka dem som cookie-fil:

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

Kom dock ihåg att dessa två steg inte är nödvändiga såvida du inte behöver bära kakor mellan olika CURL-handtag. För de flesta användningsfall är det allt du behöver att ställa CURLOPT_COOKIEFILE till den tomma strängen.

Cookiehantering kan till exempel användas för att hämta resurser från en webbplats som kräver inloggning. Detta är vanligtvis en tvåstegsprocedur. Först, POST till inloggningssidan.

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

Det andra steget (efter att standardfelkontrollen är klar) är vanligtvis en enkel GET-begäran. Det viktiga är att återanvända det befintliga CURL-handtaget för den andra begäran. Detta säkerställer att cookies från det första svaret kommer att inkluderas automatiskt i den andra begäran.

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

Detta är endast avsett som ett exempel på cookiehantering. I verkliga livet är saker oftast mer komplicerade. Ofta måste du utföra en första GET på inloggningssidan för att dra ett inloggningstoken som måste inkluderas i ditt POST. Andra webbplatser kan blockera cURL-klienten baserat på sin User-Agent-sträng, vilket kräver att du ändrar den.

Skicka flerdimensionell data och flera filer med CurlFile på en begäran

Låt oss säga att vi har en form som nedan. Vi vill skicka data till vår webbserver via AJAX och därifrån till ett skript som körs på en extern server.

Så vi har normala ingångar, ett flervalsfält och en filnedgångzon där vi kan ladda upp flera filer.

Förutsatt att AJAX POST-begäran var framgångsrik får vi följande data på PHP-webbplatsen:

// print_r($_POST)

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

och filerna ska se ut så här

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

        )

)

Än så länge är allt bra. Nu vill vi skicka dessa data och filer till den externa servern med cURL med CurlFile Class

Eftersom cURL bara accepterar en enkel men inte en multidimensionell matris måste vi först platta $ _POST-matrisen först.

För att göra detta kan du använda den här funktionen till exempel som ger dig följande:

// print_r($new_post_array)

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

Nästa steg är att skapa CurlFile Objects för de överförda filerna. Detta görs genom följande slinga:

$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 är en hjälpfunktion i CurlFile Class och skapar CurlFile-objekt. Vi sparar varje objekt i arrayen $ -filer med nycklar med namnet "upload [0]" och "upload [1]" för våra två filer.

Vi måste nu kombinera den platta inläggsenheten och filuppsättningen och spara den som $ -data som denna:

$data = $new_post_array + $files;

Det sista steget är att skicka cURL-begäran:

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

Eftersom $ data nu är en enkel (platt) matris skickar cURL automatiskt denna POST-begäran med Content Type: multipart / form-data

I upload.php på den externa servern kan du nu få postdata och filer med $ _POST och $ _FILES som du normalt skulle göra.

Skaffa och ange anpassade http-rubriker i php

Skicka begäranrubrik

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

Läser den anpassade rubriken

print_r(apache_request_headers());

OutPut: -

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

Vi kan också skicka rubriken med syntax nedan: -

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