მისაღებად მოთხოვნის მაგალითები curl php. CURL PHP: რა არის და როგორ გამოვიყენოთ იგი? POST მოთხოვნის გამოყენების მაგალითი

ამ პოსტში მე გაჩვენებთ მაგალითებით, თუ როგორ გამოიყენოთ cURL, სად გამოიყენება და რატომ უნდა გესმოდეთ, თუ ეს ჯერ არ გაგიკეთებიათ.

მოკლედ აღვწერ რა არის და რითი მიირთმევენ:

Guzzle შეიქმნა HTTP მოთხოვნების გაგზავნის პროცესის გასამარტივებლად. ხშირად გამოიყენება მოთხოვნის გასაგზავნად APIდა საერთოდ არაფერი.

რეალური მაგალითი:

თქვენ გაქვთ API, რომელიც ახლახან შეიმუშავეთ და დროა დაიწყოთ მასთან მუშაობა. თქვენ შეგიძლიათ დაწეროთ თქვენი საკუთარი ბიბლიოთეკა ან თუნდაც მინი-კლასი მასთან მუშაობისთვის, მაგრამ (1) დიდ დროს წაგართმევთ და ეს ასეც რომ არ იყოს, სავარაუდოდ, გამოსავალი არ იქნება საუკეთესო, ( 2) მას მუდმივად სჭირდება მხარდაჭერა და გაუმჯობესება. ამ შემთხვევაში, უმჯობესია გამოიყენოთ მზა გადაწყვეტა, რომელსაც მხარს უჭერს დიდი საზოგადოება და Guzzle-ის საცავში უკვე 12 ათასი ვარსკვლავია, რაც ძალიან დასაფასებელია.

თქვენ შეიძლება იკითხოთ: რატომ არის ეს აუცილებელი, თუ უკვე არსებობს უამრავი ბიბლიოთეკა?

Guzzle-მა თავისთავად შეაგროვა ყველაფერი საუკეთესო, კიდევ უფრო გააუმჯობესა და ახლა არის ყველაზე პოპულარული PHP ბიბლიოთეკა HTTP მოთხოვნებთან მუშაობისთვის. ძალიან მაგარია, უბრალოდ შეხედეთ მოთხოვნის სიმარტივეს:

// ქმნის კლიენტს საბაზისო URI-ით $client = new GuzzleHttp\Client(["base_uri" => "http://site/"]); // ახლა თქვენ შეგიძლიათ გაგზავნოთ მოთხოვნა http://bologe-ზე.. Guzzle-ს ახსოვს საბაზისო ბმული და ახლა შეგიძლიათ მხოლოდ შემდეგი გვერდების მითითება მოხერხებულობისთვის $response = $client->request("GET", "about");

მაგარია? Მე მიყვარს.

გუზლის დოკუმენტაცია საკმაოდ ვრცელია, ყველა ვარიანტის აღწერა შეუძლებელია და ამას მთელი პოსტი სჭირდება, რომელსაც აუცილებლად დავწერ მალე :)

შემდგომი სიტყვა

თუ თქვენ გაქვთ რაიმე შეკითხვები, დაწერეთ ისინი ქვემოთ ამ პოსტზე და მოხარული ვიქნები დაგეხმაროთ. ასევე, თუ თქვენ გაქვთ რაიმე შესწორება სტატიაში და სადმე დაინახეთ შეცდომა ან რაიმეს დამატება გსურთ, სიამოვნებით მოგისმენთ.

ბოლო სტატიაში განვიხილეთ. თუმცა, ზოგჯერ სცენარი მხოლოდ იღებს მიიღეთ მოთხოვნები(როგორც წესი, ეს არის საძიებო სკრიპტები). და იმისათვის, რომ დაამუშავოთ და მიიღოთ მონაცემები ასეთი სკრიპტებიდან, თქვენ უნდა შეძლოთ გაგზავნეთ GET მოთხოვნები cURL-შიასევე, რასაც გაიგებთ ამ სტატიის წაკითხვით.

პრინციპი GET მოთხოვნების გაგზავნა cURL-შიაბსოლუტურად იგივე, რაც გაგზავნა POST მეთოდით: Იქ არის წყარო ფაილიდა არსებობს დანიშნულების ფაილი. წყარო ფაილი მოდულის გამოყენებით cURL, აგზავნის GET მოთხოვნასდანიშნულების ფაილამდე. დანიშნულების ფაილი ამუშავებს ამ მოთხოვნას და აბრუნებს შედეგს, რომელიც მიღებულია საწყისი ფაილის მიერ, ისევ შესაძლებლობების გამოყენებით cURL.

იმისათვის, რომ ყველაფერი აბსოლუტურად გასაგები გახდეს, მოდით შევხედოთ მარტივ მაგალითს, რომელიც ჩვენ შევხედეთ როდის POST მოთხოვნის გაგზავნა. ანუ, წყაროს ფაილი აგზავნის ორ რიცხვს, დანიშნულების ფაილი აბრუნებს ამ რიცხვების ჯამს, რომელსაც წყაროს ფაილი იღებს და წერს ცვლადში, რომელიც შემდეგ გამოდის ბრაუზერში.

დასაწყისისთვის, დანიშნულების ფაილი (" მიმღები.php"):

$a = $_GET["a"];
$b = $_GET["b"];
ექო $a + $b;
?>

აქ ყველაფერი ძალიან მარტივია: ჩვენ ვწერთ ცვლადებში $aდა $bმონაცემებიდან მიიღეთ მოთხოვნა, და შემდეგ ვაჩვენებთ მათ ჯამს, რომელიც მიიღება წყაროს ფაილში.

ახლა მოდით შევქმნათ ფაილი თავად -

CURL (კლიენტის URLs) ბიბლიოთეკა საშუალებას გაძლევთ გადაიტანოთ ფაილები დისტანციურ კომპიუტერზე სხვადასხვა ინტერნეტ პროტოკოლების გამოყენებით. მას აქვს ძალიან მოქნილი კონფიგურაცია და საშუალებას გაძლევთ შეასრულოთ თითქმის ნებისმიერი დისტანციური მოთხოვნა.

CURL მხარს უჭერს HTTP, HTTPS, FTP, FTPS, DICT, TELNET, LDAP, FILE და GOPHER პროტოკოლებს, ასევე HTTP-post, HTTP-put, ქუქი ფაილებს, FTP ატვირთვებს, ფაილების შეწყვეტილი გადაცემის განახლებას, პაროლებს, პორტის ნომრებს, სერთიფიკატებს SSL. , კერბეროები და მარიონეტები.

CURL-ის გამოყენებით, ვებ სერვერს შეუძლია იმოქმედოს როგორც HTTP პროტოკოლზე დაფუძნებული ნებისმიერი სერვისის სრულფასოვანი კლიენტი, მაგალითად: XML-RPC, SOAP ან WebDAV.

ზოგადად, ბიბლიოთეკის გამოყენება ოთხ ეტაპზე მოდის:

  1. CURL რესურსის შექმნა curl_init ფუნქციის გამოყენებით.
  2. პარამეტრების დაყენება curl_setopt ფუნქციის გამოყენებით.
  3. მოთხოვნის შესრულება curl_exec ფუნქციის გამოყენებით.
  4. CURL რესურსის გათავისუფლება curl_close ფუნქციის გამოყენებით.

CURL-ის გამოყენების მარტივი მაგალითი

// Curl ბიბლიოთეკის ინიციალიზაცია
თუ ($ch = @curl_init())
{
// დააყენეთ მოთხოვნის URL
@curl_setopt ($ch, CURLOPT_URL, "http://server.com/");
// თუ მართალია, CURL შეიცავს სათაურებს გამოსავალში
@
// სად განვათავსოთ მოთხოვნის შედეგი:
// false - სტანდარტული გამომავალი ნაკადისკენ,
// true - როგორც curl_exec ფუნქციის დაბრუნების მნიშვნელობა.
@
// ლოდინის მაქსიმალური დრო წამებში
@
// დააყენეთ User-agent ველის მნიშვნელობა
@curl_setopt($ch, CURLOPT_USERAGENT, "PHP Bot (http://blog.yousoft.ru)");
// მოთხოვნის შესრულება
$data = @curl_exec($ch);
// მიღებული მონაცემების გამოტანა
echo $data ;
// რესურსის გამოშვება
@curl_close ($ch);
}
?>

GET მოთხოვნის გამოყენების მაგალითი

$ch = curl_init();
// GET მოთხოვნა მითითებულია URL ხაზში
curl_setopt($ch, CURLOPT_URL, "http://server.com/?s=CURL");
curl_setopt ($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);

$data = curl_exec($ch);
curl_close ($ch);
?>

GET მოთხოვნის გაგზავნა არაფრით განსხვავდება გვერდის მიღებისგან. მნიშვნელოვანია აღინიშნოს, რომ შეკითხვის სტრიქონი იქმნება შემდეგნაირად:

Http://server.com/index.php?name1=value1&name2=value2&name3=value3

სადაც http://server.com/index.php არის გვერდის მისამართი, nameX არის ცვლადის სახელი, valueX არის ცვლადის მნიშვნელობა.

POST მოთხოვნის გამოყენების მაგალითი

$ch = curl_init();
curl_setopt ($ch, CURLOPT_URL, "http://server.com/index.php");
curl_setopt ($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
// თქვენ პირდაპირ უნდა მიუთითოთ, რომ იქნება POST მოთხოვნა
curl_setopt($ch, CURLOPT_POST, true);
// ცვლადი მნიშვნელობები გადაეცემა აქ
curl_setopt ($ch, CURLOPT_POSTFIELDS, "s=CURL");
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
curl_setopt ($ch, CURLOPT_USERAGENT, "PHP Bot (http://mysite.ru)");
$data = curl_exec($ch);
curl_close ($ch);
?>

POST მოთხოვნის გაგზავნა დიდად არ განსხვავდება GET მოთხოვნის გაგზავნისგან. ყველა ძირითადი ნაბიჯი იგივე რჩება. ცვლადები ასევე მითითებულია წყვილებში: name1=value1&name2=value2.

HTTP ავტორიზაციის მაგალითი

// HTTP ავტორიზაცია
$url = "http://server.com/protected/";
$ch = curl_init();


curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword");
$შედეგი = curl_exec($ch);
curl_close ($ch);
ექო $შედეგი ;
?>

FTP სესიის მაგალითი

$fp = fopen(__FILE__, "r");
$url = "ftp://username: [ელფოსტა დაცულია]:21/path/to/newfile.php";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_UPLOAD, 1);
curl_setopt ($ch, CURLOPT_INFILE, $fp);
curl_setopt($ch, CURLOPT_FTPASCII, 1);
curl_setopt($ch, CURLOPT_INFILESIZE, ფაილის ზომა(__FILE__));
$შედეგი = curl_exec($ch);
curl_close ($ch);
?>

თუ პრობლემები გაქვთ cURL-ის გამოყენებასთან დაკავშირებით, თქვენ უნდა დაამატოთ შემდეგი ხაზები curl_close-ის დარეკვამდე ბოლო მოთხოვნის შესახებ ანგარიშის მისაღებად:

print_r(curl_getinfo($ch));
echo "cURL შეცდომის ნომერი:" . curl_errno ($ch). "
" ;
ექო "cURL შეცდომა:" . curl_error ($ch). "
" ;
curl_close ($ch);
?>

cURL არის სპეციალური ინსტრუმენტი, რომელიც შექმნილია ფაილებისა და მონაცემების გადასატანად URL სინტაქსის გამოყენებით. ეს ტექნოლოგია მხარს უჭერს ბევრ პროტოკოლს, როგორიცაა HTTP, FTP, TELNET და მრავალი სხვა. cURL თავდაპირველად შეიქმნა ბრძანების ხაზის ხელსაწყოზე. ჩვენდა საბედნიეროდ, cURL ბიბლიოთეკას მხარს უჭერს PHP პროგრამირების ენა. ამ სტატიაში განვიხილავთ cURL-ის რამდენიმე მოწინავე ფუნქციას და ასევე შევეხებით შეძენილი ცოდნის პრაქტიკულ გამოყენებას PHP-ის გამოყენებით.

რატომ cURL?

სინამდვილეში, ვებ გვერდის შინაარსის ნიმუშის რამდენიმე ალტერნატიული გზა არსებობს. ხშირ შემთხვევაში, ძირითადად სიზარმაცის გამო, cURL-ის ნაცვლად ვიყენებდი მარტივ PHP ფუნქციებს:

$content = file_get_contents ("http://www.nettuts.com"); // ან $lines = ფაილი ("http://www.nettuts.com"); // ან readfile ("http://www.nettuts.com");

თუმცა, ამ ფუნქციებს პრაქტიკულად არ აქვთ მოქნილობა და შეიცავს უამრავ ხარვეზს შეცდომების დამუშავების თვალსაზრისით და ა.შ. გარდა ამისა, არის გარკვეული ამოცანები, რომლებსაც უბრალოდ ვერ შეასრულებთ ამ სტანდარტული ფუნქციებით: ქუქიების ურთიერთქმედება, ავთენტიფიკაცია, ფორმის წარდგენა, ფაილის ატვირთვა და ა.შ.

cURL არის მძლავრი ბიბლიოთეკა, რომელიც მხარს უჭერს მრავალ განსხვავებულ პროტოკოლს, ვარიანტს და უზრუნველყოფს დეტალურ ინფორმაციას URL მოთხოვნების შესახებ.

ძირითადი სტრუქტურა

  • ინიციალიზაცია
  • პარამეტრების მინიჭება
  • შესრულება და შედეგის მიღება
  • მეხსიერების გათავისუფლება

// 1. ინიციალიზაცია $ch = curl_init(); // 2. მიუთითეთ პარამეტრები, მათ შორის url curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. მიიღეთ HTML შედეგი $output = curl_exec($ch); // 4. დახურეთ კავშირი curl_close($ch);

ნაბიჯი #2 (ანუ curl_setopt()-ის გამოძახება) ამ სტატიაში ბევრად უფრო იქნება განხილული, ვიდრე ყველა სხვა ნაბიჯი, რადგან ამ ეტაპზე ხდება ყველა ყველაზე საინტერესო და სასარგებლო რამ, რაც უნდა იცოდეთ. cURL-ში არის უამრავი სხვადასხვა ვარიანტი, რომელიც უნდა იყოს მითითებული, რათა შესაძლებელი იყოს URL-ის მოთხოვნის კონფიგურაცია ყველაზე ფრთხილად. ჩვენ არ განვიხილავთ მთელ ჩამონათვალს, მაგრამ ყურადღებას გავამახვილებთ მხოლოდ იმაზე, რაც მე მიმაჩნია საჭიროდ და სასარგებლოდ ამ გაკვეთილისთვის. თუ ეს თემა გაინტერესებთ, შეგიძლიათ თავად შეისწავლოთ ყველაფერი.

შეცდომის შემოწმება

გარდა ამისა, თქვენ ასევე შეგიძლიათ გამოიყენოთ პირობითი განცხადებები, რათა შეამოწმოთ თუ არა ოპერაცია წარმატებით დასრულდა:

// ... $გამომავალი = curl_exec($ch); if ($output === FALSE) (echo "cURL შეცდომა: " . curl_error($ch); ) // ...

აქვე გთხოვთ, გაითვალისწინოთ ძალიან მნიშვნელოვანი პუნქტი: შედარებისთვის უნდა გამოვიყენოთ „=== false“, ნაცვლად „== false“. მათთვის, ვინც არ იცის, ეს დაგვეხმარება განვასხვავოთ ცარიელი შედეგი და ლოგიკური მნიშვნელობა false, რაც მიუთითებს შეცდომაზე.

ინფორმაციის მიღება

კიდევ ერთი დამატებითი ნაბიჯი არის cURL მოთხოვნის შესახებ მონაცემების მიღება მისი შესრულების შემდეგ.

// ... curl_exec($ch); $info = curl_getinfo ($ch); ექო "აიღო". $info["total_time"] . "წამები url-ისთვის". $info["url"]; //...

დაბრუნებული მასივი შეიცავს შემდეგ ინფორმაციას:

  • "url"
  • "შინაარსის ტიპი"
  • "http_code"
  • "header_size"
  • "მოთხოვნის_ ზომა"
  • "ფაილის დრო"
  • "ssl_verify_result"
  • „გადამისამართების_ რაოდენობა“
  • „სულ_დრო“
  • „namelookup_time“
  • „connect_time“
  • „წინასწარ გადაცემის_დრო“
  • "size_upload"
  • "ზომა_ჩამოტვირთვა"
  • "speed_download"
  • "speed_upload"
  • „ჩამოტვირთვა_კონტენტის_სიგრძე“
  • „ატვირთვის_კონტენტის_სიგრძე“
  • „დაწყების გადაცემის დრო“
  • „გადამისამართების_დრო“

გადამისამართების აღმოჩენა ბრაუზერის მიხედვით

ამ პირველ მაგალითში ჩვენ დავწერთ კოდს, რომელსაც შეუძლია URL-ის გადამისამართების აღმოჩენა ბრაუზერის სხვადასხვა პარამეტრებზე დაყრდნობით. მაგალითად, ზოგიერთი ვებსაიტი გადამისამართებს მობილური ტელეფონის ან სხვა მოწყობილობის ბრაუზერებს.

ჩვენ ვაპირებთ გამოვიყენოთ CURLOPT_HTTPHEADER ვარიანტი ჩვენი გამავალი HTTP სათაურების განსასაზღვრად, მომხმარებლის ბრაუზერის სახელისა და ხელმისაწვდომი ენების ჩათვლით. საბოლოოდ ჩვენ შევძლებთ განვსაზღვროთ რომელი საიტები გვიგზავნიან სხვადასხვა URL-ებზე.

// შეამოწმეთ URL $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // ბრაუზერების ტესტირება $browsers = array("სტანდარტული" => მასივი ("user_agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5 .6 (.NET CLR 3.5.30729)", "language" => "en-us,en;q=0.5"), "iphone" => მასივი ("user_agent" => "Mozilla/5.0 (iPhone; U ; CPU, როგორიცაა Mac OS X; => "Mozilla/4.0 (თავსებადი; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "language" => "fr,fr-FR;q=0.5")); foreach ($urls როგორც $url) ( echo "URL: $url\n"; foreach ($browsers როგორც $test_name => $browser) ($ch = curl_init(); // მიუთითეთ url curl_setopt($ch, CURLOPT_URL , $url // მიუთითეთ სათაურები ბრაუზერისთვის curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"]), "Accept-Language: ($browser["language"]; )" )); // ჩვენ არ გვჭირდება გვერდის შინაარსი curl_setopt($ch, CURLOPT_NOBODY, 1); // ჩვენ უნდა მივიღოთ HTTP სათაურები curl_setopt($ch, CURLOPT_HEADER, 1); // შედეგების დაბრუნება curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1 $output = curl_exec($ch) იყო თუ არა HTTP გადამისამართება ("!Location: (.*)!"; , $matches) (echo "$test_name: გადამისამართდება $matches\n";) else (echo "$test_name: no redirection\n"; ) ) echo "\n\n";

პირველ რიგში, ჩვენ ვაზუსტებთ იმ საიტების URL-ების ჩამონათვალს, რომლებსაც შევამოწმებთ. უფრო სწორედ, დაგვჭირდება ამ საიტების მისამართები. შემდეგ ჩვენ უნდა განვსაზღვროთ ბრაუზერის პარამეტრები თითოეული ამ URL-ის შესამოწმებლად. ამის შემდეგ ჩვენ გამოვიყენებთ მარყუჟს, რომელშიც გავივლით ყველა მიღებულ შედეგს.

ხრიკი, რომელსაც ამ მაგალითში ვიყენებთ cURL პარამეტრების დასაყენებლად, საშუალებას მოგვცემს მივიღოთ არა გვერდის შინაარსი, არამედ მხოლოდ HTTP სათაურები (შენახული $output-ში). შემდეგი, მარტივი რეგექსის გამოყენებით, ჩვენ შეგვიძლია განვსაზღვროთ, იყო თუ არა სტრიქონი "Location:" მიღებულ სათაურებში.

ამ კოდის გაშვებისას, თქვენ უნდა მიიღოთ მსგავსი რამ:

POST მოთხოვნის შექმნა კონკრეტულ URL-ზე

GET მოთხოვნის ფორმირებისას, გადაცემული მონაცემები შეიძლება გადაეცეს URL-ს „კითხვის სტრიქონის“ მეშვეობით. მაგალითად, როდესაც თქვენ აკეთებთ Google ძიებას, საძიებო სიტყვა მოთავსებულია ახალი URL-ის მისამართების ზოლში:

Http://www.google.com/search?q=ruseller

თქვენ არ გჭირდებათ cURL-ის გამოყენება ამ მოთხოვნის სიმულაციისთვის. თუ სიზარმაცე მთლიანად დაგძლევს, შედეგის მისაღებად გამოიყენეთ ფუნქცია “file_get_contents()”.

მაგრამ საქმე ის არის, რომ ზოგიერთი HTML ფორმა აგზავნის POST მოთხოვნებს. ამ ფორმების მონაცემები ტრანსპორტირდება HTTP მოთხოვნის ორგანოს მეშვეობით და არა როგორც წინა შემთხვევაში. მაგალითად, თუ თქვენ შეავსეთ ფორმა ფორუმზე და დააწკაპუნეთ ძებნის ღილაკზე, მაშინ, სავარაუდოდ, POST მოთხოვნა გაკეთდება:

Http://codeigniter.com/forums/do_search/

ჩვენ შეგვიძლია დავწეროთ PHP სკრიპტი, რომელსაც შეუძლია ამ ტიპის URL მოთხოვნის სიმულაცია. ჯერ შევქმნათ მარტივი ფაილი POST მონაცემების მისაღებად და საჩვენებლად. მოდით ვუწოდოთ მას post_output.php:

Print_r ($_POST);

შემდეგ ჩვენ ვქმნით PHP სკრიპტს cURL მოთხოვნის გასაკეთებლად:

$url = "http://localhost/post_output.php"; $post_data = მასივი ("foo" => "ზოლი", "query" => "Nettuts", "action" => "გაგზავნა"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ, რომ გვაქვს POST მოთხოვნა curl_setopt($ch, CURLOPT_POST, 1); // ცვლადების დამატება curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

ამ სკრიპტის გაშვებისას თქვენ უნდა მიიღოთ ასეთი შედეგი:

ამრიგად, POST მოთხოვნა გაიგზავნა post_output.php სკრიპტზე, რომელიც თავის მხრივ გამოსცემს სუპერგლობალურ $_POST მასივს, რომლის შიგთავსი მივიღეთ cURL-ის გამოყენებით.

ფაილის ატვირთვა

პირველ რიგში, მოდით შევქმნათ ფაილი მისი გენერირების მიზნით და გავაგზავნოთ upload_output.php ფაილში:

Print_r ($_FILES);

და აქ არის სკრიპტის კოდი, რომელიც ასრულებს ზემოთ მოცემულ ფუნქციებს:

$url = "http://localhost/upload_output.php"; $post_data = მასივი ("foo" => "ზოლი", // ფაილი ასატვირთად "ატვირთვა" => "@C:/wamp/www/test.zip"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

როდესაც გსურთ ფაილის ატვირთვა, საკმარისია გადასცეთ ის, როგორც ჩვეულებრივი პოსტის ცვლადი, რომელსაც წინ უძღვის @ სიმბოლო. თქვენს მიერ დაწერილი სკრიპტის გაშვებისას მიიღებთ შემდეგ შედეგს:

მრავალი cURL

cURL-ის ერთ-ერთი ყველაზე ძლიერი მხარე არის cURL-ის "მრავალჯერადი" დამმუშავებლის შექმნის შესაძლებლობა. ეს საშუალებას გაძლევთ გახსნათ კავშირი მრავალ URL-თან ერთდროულად და ასინქრონულად.

cURL მოთხოვნის კლასიკურ ვერსიაში სკრიპტის შესრულება შეჩერებულია და ელოდება მოთხოვნის URL ოპერაციის დასრულებას, რის შემდეგაც სკრიპტის გაგრძელება შეიძლება. თუ თქვენ აპირებთ ინტერაქციას URL-ების მთელ ჯგუფთან, ეს გამოიწვევს დროის საკმაოდ მნიშვნელოვან ინვესტიციას, რადგან კლასიკურ ვერსიაში შეგიძლიათ ერთდროულად იმუშაოთ მხოლოდ ერთი URL-ით. თუმცა, ჩვენ შეგვიძლია გამოვასწოროთ ეს სიტუაცია სპეციალური დამმუშავებლების გამოყენებით.

მოდით გადავხედოთ php.net-დან აღებული კოდის მაგალითს:

// რამდენიმე cURL რესურსის შექმნა $ch1 = curl_init(); $ch2 = curl_init(); // მიუთითეთ URL და სხვა პარამეტრები curl_setopt($ch1, CURLOPT_URL, "http://lxr.php.net/"); curl_setopt($ch1, CURLOPT_HEADER, 0); curl_setopt ($ch2, CURLOPT_URL, "http://www.php.net/"); curl_setopt($ch2, CURLOPT_HEADER, 0); //მრავალჯერადი cURL დამმუშავებლის შექმნა $mh = curl_multi_init(); //დაამატე რამდენიმე დამმუშავებელი curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $active = null; //შეასრულეთ გაკეთება ($mrc = curl_multi_exec($mh, $active); ) ხოლო ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc ​​== CURLM_OK) ( if (curl_multi_select($mh) != -1) (do ($mrc = curl_multi_exec($mh, $active); ) ხოლო ($mrc == CURLM_CALL_MULTI_PERFORM ) ) //curl_multi_remove_handle-ის დახურვა ($mh, $ch1); curl_multi_remove_handle ($mh, $ch2); curl_multi_close($mh);

იდეა არის ის, რომ შეგიძლიათ გამოიყენოთ მრავალი cURL დამმუშავებელი. მარტივი მარყუჟის გამოყენებით, შეგიძლიათ თვალყური ადევნოთ, რომელი მოთხოვნები ჯერ არ დასრულებულა.

ამ მაგალითში ორი ძირითადი მარყუჟია. პირველი do-while ციკლი მოუწოდებს curl_multi_exec(). ეს ფუნქცია არ არის დაბლოკილი. ის მუშაობს რაც შეიძლება სწრაფად და აბრუნებს მოთხოვნის სტატუსს. სანამ დაბრუნებული მნიშვნელობა არის მუდმივი „CURLM_CALL_MULTI_PERFORM“, ეს ნიშნავს, რომ სამუშაო ჯერ არ დასრულებულა (მაგალითად, http სათაურები ამჟამად იგზავნება URL-ზე); ამიტომ ჩვენ ვაგრძელებთ ამ დაბრუნების მნიშვნელობის შემოწმებას, სანამ არ მივიღებთ განსხვავებულ შედეგს.

შემდეგ ციკლში ჩვენ ვამოწმებთ მდგომარეობას, ხოლო ცვლადი $active = "true". ეს არის curl_multi_exec() ფუნქციის მეორე პარამეტრი. ამ ცვლადის მნიშვნელობა იქნება "true", სანამ ნებისმიერი არსებული ცვლილება აქტიურია. შემდეგ ჩვენ მოვუწოდებთ curl_multi_select() ფუნქციას. მისი შესრულება "დაბლოკილია", სანამ არის მინიმუმ ერთი აქტიური კავშირი, სანამ პასუხი არ მიიღება. როდესაც ეს მოხდება, ჩვენ ვუბრუნდებით მთავარ ციკლს, რათა გავაგრძელოთ მოთხოვნების შესრულება.

ახლა მოდით გამოვიყენოთ ეს ცოდნა მაგალითზე, რომელიც ნამდვილად გამოადგება ხალხის დიდ რაოდენობას.

ბმულების შემოწმება WordPress-ში

წარმოიდგინეთ ბლოგი დიდი რაოდენობით პოსტებითა და შეტყობინებებით, რომელთაგან თითოეული შეიცავს ბმულებს გარე ინტერნეტ რესურსებზე. ამ ბმულებიდან ზოგიერთი შეიძლება უკვე მკვდარი იყოს სხვადასხვა მიზეზის გამო. გვერდი შესაძლოა წაშლილია ან საიტი საერთოდ არ მუშაობს.

ჩვენ ვაპირებთ შევქმნათ სკრიპტი, რომელიც გააანალიზებს ყველა ბმულს და იპოვის არაჩამტვირთველ ვებსაიტებს და 404 გვერდებს, შემდეგ კი მოგვაწვდის დეტალურ ანგარიშს.

ნება მომეცით დაუყოვნებლივ ვთქვა, რომ ეს არ არის WordPress-ისთვის მოდულის შექმნის მაგალითი. ეს არის აბსოლუტურად კარგი საცდელი ადგილი ჩვენი ტესტებისთვის.

საბოლოოდ დავიწყოთ. პირველ რიგში, ჩვენ უნდა მივიღოთ ყველა ბმული მონაცემთა ბაზიდან:

// კონფიგურაცია $db_host = "localhost"; $db_user = "root"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = მასივი ("localhost", "www.mydomain.com"); $max_connections = 10; // ცვლადების ინიციალიზაცია $url_list = array(); $working_urls = მასივი(); $dead_urls = მასივი(); $not_found_urls = მასივი(); $active = null; // დაუკავშირდით MySQL-ს, თუ (!mysql_connect($db_host, $db_user, $db_pass)) ( die("დაკავშირება ვერ მოხერხდა: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("შეუძლია არ აირჩიეთ db: " . mysql_error()); ) // აირჩიეთ ყველა გამოქვეყნებული პოსტი, რომელსაც აქვს ბმული $q = "SELECT post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "publish" AND post_type = "post " "; $r = mysql_query($q) ან die(mysql_error()); while ($d = mysql_fetch_assoc($r)) (// ბმულების მიღება რეგულარული გამონათქვამების გამოყენებით, if (preg_match_all("!href=\"(.*?)\"!", $d["post_content"], $ შეესაბამება) ) ( foreach ($ შეესაბამება $url-ს) ( $tmp = parse_url ($url); if (in_array($tmp["host"], $excluded_domains)) ( გაგრძელება; ) $url_list = $url; ) ) ) / ამოიღეთ დუბლიკატები $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die ("URL არ არის შესამოწმებელი"); )

ჯერ ვაგენერირებთ კონფიგურაციის მონაცემებს მონაცემთა ბაზასთან ურთიერთქმედებისთვის, შემდეგ ვწერთ იმ დომენების სიას, რომლებიც არ მიიღებენ მონაწილეობას შემოწმებაში ($excluded_domains). ჩვენ ასევე განვსაზღვრავთ რიცხვს, რომელიც ახასიათებს მაქსიმალური ერთდროული კავშირების რაოდენობას, რომლებსაც გამოვიყენებთ ჩვენს სკრიპტში ($max_connections). შემდეგ ვუერთდებით მონაცემთა ბაზას, ვირჩევთ პოსტებს, რომლებიც შეიცავს ბმულებს და ვაგროვებთ მათ მასივში ($url_list).

შემდეგი კოდი ცოტა რთულია, ასე რომ გაიარეთ თავიდან ბოლომდე:

// 1. მრავალჯერადი დამმუშავებელი $mh = curl_multi_init(); // 2. დაამატეთ URL-ების ნაკრები ($i = 0; $i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // 3. инициализация выполнения do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. основной цикл while ($active && $mrc == CURLM_OK) { // 5. если всё прошло успешно if (curl_multi_select($mh) != -1) { // 6. делаем дело do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 7. если есть инфа? if ($mhinfo = curl_multi_info_read($mh)) { // это значит, что запрос завершился // 8. извлекаем инфу $chinfo = curl_getinfo($mhinfo["handle"]); // 9. мёртвая ссылка? if (!$chinfo["http_code"]) { $dead_urls = $chinfo["url"]; // 10. 404? } else if ($chinfo["http_code"] == 404) { $not_found_urls = $chinfo["url"]; // 11. рабочая } else { $working_urls = $chinfo["url"]; } // 12. чистим за собой curl_multi_remove_handle($mh, $mhinfo["handle"]); // в случае зацикливания, закомментируйте данный вызов curl_close($mhinfo["handle"]); // 13. добавляем новый url и продолжаем работу if (add_url_to_multi_handle($mh, $url_list)) { do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); } } } } // 14. завершение curl_multi_close($mh); echo "==Dead URLs==\n"; echo implode("\n",$dead_urls) . "\n\n"; echo "==404 URLs==\n"; echo implode("\n",$not_found_urls) . "\n\n"; echo "==Working URLs==\n"; echo implode("\n",$working_urls); function add_url_to_multi_handle($mh, $url_list) { static $index = 0; // если у нас есть ещё url, которые нужно достать if ($url_list[$index]) { // новый curl обработчик $ch = curl_init(); // указываем url curl_setopt($ch, CURLOPT_URL, $url_list[$index]); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); curl_setopt($ch, CURLOPT_NOBODY, 1); curl_multi_add_handle($mh, $ch); // переходим на следующий url $index++; return true; } else { // добавление новых URL завершено return false; } }

აქ შევეცდები დეტალურად ავხსნა ყველაფერი. სიაში ნომრები შეესაბამება კომენტარში მოცემულ ნომრებს.

  1. 1. მრავალჯერადი დამმუშავებლის შექმნა;
  2. 2. add_url_to_multi_handle() ფუნქციას ცოტა მოგვიანებით დავწერთ. ყოველ ჯერზე დარეკვისას დაიწყება ახალი url-ის დამუშავება. თავდაპირველად ვამატებთ 10 ($max_connections) URL-ს;
  3. 3. დასაწყებად უნდა გავუშვათ curl_multi_exec() ფუნქცია. სანამ ის დააბრუნებს CURLM_CALL_MULTI_PERFORM-ს, ჩვენ ჯერ კიდევ გვაქვს გასაკეთებელი. ეს ძირითადად კავშირების შესაქმნელად გვჭირდება;
  4. 4. შემდეგ მოდის მთავარი ციკლი, რომელიც იმუშავებს მანამ, სანამ გვექნება მინიმუმ ერთი აქტიური კავშირი;
  5. 5. curl_multi_select() ჩერდება URL ძიების დასრულებას;
  6. 6. კიდევ ერთხელ, ჩვენ უნდა მივიღოთ cURL გარკვეული სამუშაოს შესასრულებლად, კერძოდ, მივიღოთ დაბრუნების პასუხის მონაცემები;
  7. 7. ინფორმაცია აქ გადამოწმებულია. მოთხოვნის შესრულების შედეგად მასივი დაბრუნდება;
  8. 8. დაბრუნებული მასივი შეიცავს cURL დამმუშავებელს. ჩვენ მას გამოვიყენებთ ცალკე cURL მოთხოვნის შესახებ ინფორმაციის შესარჩევად;
  9. 9. თუ ბმული მკვდარი იყო, ან სკრიპტის დრო ამოიწურა, მაშინ არ უნდა ვეძებოთ რაიმე http კოდი;
  10. 10. თუ ლინკმა დაგვიბრუნა 404 გვერდი, მაშინ http კოდი შეიცავს 404 მნიშვნელობას;
  11. 11. წინააღმდეგ შემთხვევაში, ჩვენ წინ გვაქვს სამუშაო ბმული. (შეგიძლიათ დაამატოთ დამატებითი შემოწმებები შეცდომის კოდისთვის 500 და ა.შ.);
  12. 12. შემდეგ ჩვენ ვხსნით cURL დამმუშავებელს, რადგან ის აღარ გვჭირდება;
  13. 13. ახლა შეგვიძლია დავამატოთ კიდევ ერთი url და გავუშვათ ყველაფერი, რაზეც ადრე ვისაუბრეთ;
  14. 14. ამ ეტაპზე სკრიპტი ასრულებს თავის სამუშაოს. ჩვენ შეგვიძლია წავშალოთ ყველაფერი, რაც არ გვჭირდება და შევქმნათ ანგარიში;
  15. 15. ბოლოს დავწერთ ფუნქციას, რომელიც დაამატებს url-ს დამმუშავებელს. სტატიკური ცვლადი $index გაიზრდება ყოველ ჯერზე ამ ფუნქციის გამოძახებისას.

მე გამოვიყენე ეს სკრიპტი ჩემს ბლოგზე (ზოგიერთი გატეხილი ლინკით, რომლებიც განზრახ დავამატე მის შესამოწმებლად) და მივიღე შემდეგი შედეგი:

ჩემს შემთხვევაში, სკრიპტს 2 წამზე ცოტა ნაკლები დასჭირდა 40 URL-ის გადასინჯვას. შესრულების მატება მნიშვნელოვანია კიდევ უფრო მეტ URL-თან მუშაობისას. თუ ერთდროულად გახსნით ათ კავშირს, სკრიპტს შეუძლია ათჯერ უფრო სწრაფად შეასრულოს.

რამდენიმე სიტყვა სხვა სასარგებლო cURL ვარიანტების შესახებ

HTTP ავთენტიფიკაცია

თუ URL-ს აქვს HTTP ავთენტიფიკაცია, მაშინ მარტივად შეგიძლიათ გამოიყენოთ შემდეგი სკრიპტი:

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ მომხმარებლის სახელი და პაროლი curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // თუ გადამისამართება დასაშვებია curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // შემდეგ შეინახეთ ჩვენი მონაცემები cURL curl_setopt ($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close ($ch);

FTP ატვირთვა

PHP-ს ასევე აქვს ბიბლიოთეკა FTP-თან მუშაობისთვის, მაგრამ არაფერი გიშლით ხელს აქ cURL ინსტრუმენტების გამოყენებაში:

// გახსენით ფაილი $file = fopen("/path/to/file", "r"); // url უნდა შეიცავდეს შემდეგ შინაარსს $url = "ftp://username: [ელფოსტა დაცულია]:21/გზა/ახალი/ფაილი"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp curl_setopt($ch, CURLOPT_INFILESIZE, ფაილის ზომა("/path/to/file") curl_close($ch);

პროქსის გამოყენება

თქვენ შეგიძლიათ შეასრულოთ თქვენი URL მოთხოვნა პროქსის მეშვეობით:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ მისამართი curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // თუ გჭირდებათ მომხმარებლის სახელი და პაროლი curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $output = curl_exec($ch); curl_close ($ch);

გამოძახების ფუნქციები

ასევე შესაძლებელია მიუთითოთ ფუნქცია, რომელიც ამოქმედდება cURL მოთხოვნის დასრულებამდეც კი. მაგალითად, სანამ საპასუხო კონტენტი იტვირთება, შეგიძლიათ დაიწყოთ მონაცემების გამოყენება სრულად ჩატვირთვის მოლოდინის გარეშე.

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://net.tutsplus.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"პროგრესი_ფუნქცია"); curl_exec ($ch); curl_close ($ch); ფუნქცია progress_function($ch,$str) (echo $str; return strlen($str); )

მსგავსმა ფუნქციამ უნდა დააბრუნოს სტრიქონის სიგრძე, რაც სავალდებულოა.

დასკვნა

დღეს ჩვენ ვისწავლეთ, თუ როგორ შეგიძლიათ გამოიყენოთ cURL ბიბლიოთეკა თქვენი ეგოისტური მიზნებისთვის. იმედი მაქვს მოგეწონათ ეს სტატია.

Გმადლობთ! Კარგ დღეს გისურვებ!



 

შეიძლება სასარგებლო იყოს წაკითხვა: