PHP
Korzystanie z cURL w PHP

Składnia

• zasób curl_init ([string $ url = NULL])
• bool curl_setopt (zasób $ ch, int $ opcja, mieszana $ wartość)
• bool curl_setopt_array (zasób $ ch, tablica $ opcje)
• mieszany curl_exec (zasób $ ch)
• void curl_close (zasób $ ch)

Parametry

Podstawowe użycie (żądania GET)

cURL to narzędzie do przesyłania danych ze składnią URL. Obsługuje HTTP, FTP, SCP i wiele innych (curl> = 7.19.4). Pamiętaj, że musisz zainstalować i włączyć rozszerzenie cURL, aby z niego korzystać.

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

Żądania POST

Jeśli chcesz naśladować działanie HTML formularza POST, możesz użyć 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);

Używanie multi_curl do wykonywania wielu żądań POST

Czasami musimy wykonać wiele żądań POST do jednego lub wielu różnych punktów końcowych. Aby poradzić sobie z tym scenariuszem, możemy użyć multi_curl .

Po pierwsze, tworzymy tyle żądań, ile potrzeba dokładnie w taki sam sposób jak prosty przykład i umieszczamy je w tablicy.

Używamy curl_multi_init i dodajemy do niego każdy uchwyt.

W tym przykładzie używamy 2 różnych punktów końcowych:

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

Następnie używamy curl_multi_exec do wysyłania żądań

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

Możliwym zwrotem dla tego przykładu może być:

Żądanie „ http://www.example.com ” zwróciło „owoce” w ciągu 2 sekund.

Żądanie do „ http://www.example2.com ” zwróciło „owoce morza” w 5 sekund.

Tworzenie i wysyłanie żądania za pomocą niestandardowej metody

Domyślnie PHP Curl obsługuje POST GET i POST . Możliwe jest również wysyłanie niestandardowych żądań, takich jak DELETE , PUT lub PATCH (lub nawet niestandardowe metody) za pomocą parametru 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);

Korzystanie z plików cookie

cURL może przechowywać otrzymane pliki cookie w odpowiedziach do wykorzystania przy kolejnych żądaniach. W przypadku prostej obsługi plików cookie sesji w pamięci uzyskuje się to za pomocą jednego wiersza kodu:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

W przypadkach, w których musisz przechowywać pliki cookie po zniszczeniu uchwytu cURL, możesz określić plik, w którym będą przechowywane:

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

Następnie, jeśli chcesz ich ponownie użyć, przekaż je jako plik cookie:

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

Pamiętaj jednak, że te dwa kroki nie są konieczne, chyba że musisz przenosić pliki cookie między różnymi uchwytami CURL. W większości przypadków użycia wystarczy ustawić CURLOPT_COOKIEFILE na pusty ciąg znaków.

Obsługa plików cookie może służyć na przykład do pobierania zasobów ze strony internetowej wymagającej logowania. Zazwyczaj jest to procedura dwuetapowa. Najpierw POST na stronie logowania.

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

Drugim krokiem (po wykonaniu standardowego sprawdzania błędów) jest zwykle proste żądanie GET. Ważne jest ponowne użycie istniejącego uchwytu cURL dla drugiego żądania. Dzięki temu pliki cookie z pierwszej odpowiedzi zostaną automatycznie uwzględnione w drugim żądaniu.

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

Jest to przeznaczone wyłącznie jako przykład obsługi plików cookie. W prawdziwym życiu rzeczy są zwykle bardziej skomplikowane. Często musisz wykonać początkowy GET strony logowania, aby pobrać token logowania, który musi być uwzględniony w teście POST. Inne witryny mogą blokować klienta cURL na podstawie jego ciągu User-Agent, co wymaga jego zmiany.

Wysyłanie danych wielowymiarowych i wielu plików za pomocą CurlFile w jednym żądaniu

Powiedzmy, że mamy formularz podobny do poniższego. Chcemy wysłać dane do naszego serwera przez AJAX, a stamtąd do skryptu działającego na serwerze zewnętrznym.

Mamy więc normalne dane wejściowe, pole wielokrotnego wyboru i strefę zrzutu pliku, w której możemy przesłać wiele plików.

Zakładając, że żądanie AJAX POST zakończyło się powodzeniem, otrzymujemy następujące dane na stronie PHP:

// print_r($_POST)

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

i pliki powinny wyglądać tak

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

        )

)

Jak na razie dobrze. Teraz chcemy wysłać te dane i pliki na serwer zewnętrzny za pomocą cURL z klasą CurlFile

Ponieważ cURL akceptuje tylko prostą, ale nie wielowymiarową tablicę, musimy najpierw spłaszczyć tablicę $ _POST.

Aby to zrobić, możesz na przykład użyć tej funkcji, która zapewnia:

// print_r($new_post_array)

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

Następnym krokiem jest utworzenie obiektów CurlFile dla przesłanych plików. Odbywa się to za pomocą następującej pętli:

$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 jest funkcją pomocniczą klasy CurlFile i tworzy obiekty CurlFile. Każdy obiekt zapisujemy w tablicy $ files z kluczami o nazwie „upload [0]” i „upload [1]” dla naszych dwóch plików.

Teraz musimy połączyć spłaszczoną tablicę postów i tablicę plików i zapisać ją jako dane $ w następujący sposób:

$data = $new_post_array + $files;

Ostatnim krokiem jest wysłanie żądania 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);

Ponieważ $ data jest teraz prostą (płaską) tablicą, cURL automatycznie wysyła to żądanie POST z typem treści: multipart / form-data

W upload.php na zewnętrznym serwerze możesz teraz pobrać dane i pliki za pomocą $ _POST i $ _FILES, jak zwykle.

Pobierz i ustaw niestandardowe nagłówki http w php

Wysyłanie nagłówka żądania

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

Czytanie niestandardowego nagłówka

print_r(apache_request_headers());

Wynik :-

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

Możemy również wysłać nagłówek, używając poniższej składni: -

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