Zápis HTTP požiadaviek pomocou Curl. Zdokonaľte svoje zručnosti v práci s cURL Príklady get requestov curl php

V tomto príspevku ukážem príklady, ako používať cURL, kde sa používa a prečo by ste tomu mali rozumieť, ak ste to ešte neurobili.

Stručne popíšem, čo to je a s čím sa to jedáva:

Guzzle bol vytvorený s cieľom zjednodušiť proces odosielania požiadaviek HTTP. Často sa používa na odosielanie žiadostí na API a všeobecne čokoľvek.

Reálny príklad:

Máte API, ktoré ste nedávno vyvinuli a je čas začať s ním pracovať. Mohli by ste si napísať svoju vlastnú knižnicu alebo dokonca minitriedu, s ktorou by ste s ňou pracovali, ale (1) zabralo by vám to veľa času a aj keby tomu tak nebolo, riešenie by s najväčšou pravdepodobnosťou nebolo najlepšie, ( 2) treba ho neustále podporovať a zlepšovať. V tomto prípade je lepšie použiť hotové riešenie, ktoré podporuje veľká komunita a úložisko Guzzle má už 12 tisíc hviezdičiek, čo je veľmi chvályhodné.

Môžete sa opýtať: Prečo je to potrebné, ak už existuje veľa knižníc?

Guzzle zhromaždil všetko najlepšie v sebe, urobil to ešte lepšie a je teraz najobľúbenejšou PHP knižnicou pre prácu s HTTP požiadavkami. Je to naozaj skvelé, len sa pozrite na jednoduchosť požiadavky:

// Vytvorí klienta so základným URI $client = new GuzzleHttp\Client(["base_uri" => "http://site/"]); // Teraz môžete poslať požiadavku na http://bologe.. Guzzle si pamätá základný odkaz a teraz môžete pre pohodlie zadať iba nasledujúce stránky $response = $client->request("GET", "about");

v pohode? Veľmi sa mi to páči.

Dokumentácia Guzzle je pomerne rozsiahla, nie je možné opísať každú možnosť a to si vyžaduje celý príspevok, ktorý určite čoskoro napíšem :)

Doslov

Ak máte nejaké otázky, napíšte ich nižšie pod tento príspevok a rád vám pomôžem. Taktiež, ak máte nejaké opravy v článku a niekde ste videli chybu alebo chcete niečo doplniť, rád si vás vypočujem.

V minulom článku sme diskutovali. Niekedy však scenár iba akceptuje žiadosti GET(spravidla ide o vyhľadávacie skripty). A aby ste mohli spracovávať a prijímať údaje z takýchto skriptov, musíte byť schopní posielať požiadavky GET v cURL tiež, čo sa dozviete prečítaním tohto článku.

Princíp odosielanie žiadostí GET v cURLúplne to isté ako s odosielanie metódou POST: Existuje zdrojový súbor a tam je cieľový súbor. Zdrojový súbor pomocou modulu cURL, odošle požiadavku GET do cieľového súboru. Cieľový súbor spracuje túto požiadavku a vráti výsledok, ktorý je akceptovaný zdrojovým súborom, opäť pomocou schopností cURL.

Aby bolo všetko úplne jasné, pozrime sa na jednoduchý príklad, na ktorý sme sa pozreli kedy odosielanie žiadostí POST. To znamená, že zdrojový súbor odošle dve čísla, cieľový súbor vráti súčet týchto čísel, ktoré zdrojový súbor prijme a zapíše do premennej, ktorá sa potom vypíše do prehliadača.

Na začiatok cieľový súbor (" prijímač.php"):

$a = $_GET["a"];
$b = $_GET["b"];
echo $a + $b;
?>

Všetko je tu veľmi jednoduché: píšeme v premenných $a A $ búdaje z žiadosť GET a následne zobrazíme ich súčet, ktorý bude akceptovaný zdrojovým súborom.

Teraz vytvoríme samotný súbor -

Knižnica CURL (Client URLs) vám umožňuje prenášať súbory na vzdialený počítač pomocou rôznych internetových protokolov. Má veľmi flexibilnú konfiguráciu a umožňuje vám splniť takmer akúkoľvek vzdialenú požiadavku.

CURL podporuje protokoly HTTP, HTTPS, FTP, FTPS, DICT, TELNET, LDAP, FILE a GOPHER, ako aj HTTP-post, HTTP-put, cookies, FTP uploady, obnovenie prerušených prenosov súborov, heslá, čísla portov, certifikáty SSL , Kerberos a proxy servery.

Pomocou CURL môže webový server fungovať ako plnohodnotný klient akejkoľvek služby založenej na protokole HTTP, napríklad: XML-RPC, SOAP alebo WebDAV.

Vo všeobecnosti sa používanie knižnice skladá zo štyroch krokov:

1. Vytvorenie zdroja CURL pomocou funkcie curl_init.
2. Nastavenie parametrov pomocou funkcie curl_setopt.
3. Vykonanie požiadavky pomocou funkcie curl_exec.
4. Uvoľnenie zdroja CURL pomocou funkcie curl_close.

Jednoduchý príklad použitia CURL

// Inicializácia knižnice curl
if ($ch = @curl_init())
{
// Nastavte adresu URL požiadavky
@curl_setopt($ch, CURLOPT_URL, "http://server.com/");
// Ak je pravda, CURL obsahuje hlavičky vo výstupe
@
// Kam umiestniť výsledok požiadavky:
// false - do štandardného výstupného toku,
// true - ako návratová hodnota funkcie curl_exec.
@
// Maximálna doba čakania v sekundách
@
// Nastavte hodnotu poľa User-agent
@curl_setopt($ch, CURLOPT_USERAGENT, "PHP Bot (http://blog.yousoft.ru)");
// Vykonať požiadavku
$data = @curl_exec($ch);
// Výstup prijatých údajov
echo $data ;
// Uvoľnite zdroj
@curl_close($ch);
}
?>

Príklad použitia požiadavky GET

$ch = curl_init();
// Požiadavka GET je uvedená v riadku 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);
?>

Odoslanie požiadavky GET sa nelíši od prijatia stránky. Je dôležité poznamenať, že reťazec dotazu je vytvorený takto:

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

kde http://server.com/index.php je adresa stránky, nameX je názov premennej, hodnotaX je hodnota premennej.

Príklad použitia požiadavky 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);
// Musíte výslovne uviesť, že bude existovať požiadavka POST
curl_setopt($ch, CURLOPT_POST, pravda);
// Tu sa odovzdávajú hodnoty premenných
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);
?>

Odoslanie požiadavky POST sa príliš nelíši od odoslania požiadavky GET. Všetky základné kroky zostávajú rovnaké. Premenné sú tiež špecifikované v pároch: meno1=hodnota1&meno2=hodnota2 .

Príklad autorizácie HTTP

// HTTP autorizácia
$url = "http://server.com/protected/";
$ch = curl_init();


curl_setopt($ch, CURLOPT_USERPWD, "mojepouzivatelske meno:mojeheslo");
$vysledok = curl_exec($ch);
curl_close($ch);
echo $vysledok ;
?>

Príklad relácie FTP

$fp = fopen(__FILE__, "r");
$url = "ftp://username: [e-mail chránený]: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, veľkosť súboru(__FILE__));
$vysledok = curl_exec($ch);
curl_close($ch);
?>

Ak máte problémy s používaním cURL, musíte pred volaním curl_close pridať nasledujúce riadky, aby ste získali správu o poslednej požiadavke:

print_r(curl_getinfo($ch));
echo "číslo chyby cURL:" . curl_errno($ch). "
" ;
echo "cURL error:" . curl_error($ch). "
" ;
curl_close($ch);
?>

cURL je špeciálny nástroj, ktorý je určený na prenos súborov a údajov pomocou syntaxe URL. Táto technológia podporuje mnoho protokolov ako HTTP, FTP, TELNET a mnoho ďalších. cURL bol pôvodne navrhnutý ako nástroj príkazového riadku. Našťastie pre nás je knižnica cURL podporovaná programovacím jazykom PHP. V tomto článku sa pozrieme na niektoré pokročilé funkcie cURL a dotkneme sa aj praktickej aplikácie nadobudnutých znalostí pomocou PHP.

Prečo cURL?

V skutočnosti existuje pomerne veľa alternatívnych spôsobov vzorkovania obsahu webovej stránky. V mnohých prípadoch, hlavne kvôli lenivosti, som namiesto cURL použil jednoduché PHP funkcie:

$obsah = file_get_contents("http://www.nettuts.com"); // alebo $lines = file("http://www.nettuts.com"); // alebo readfile("http://www.nettuts.com");

Tieto funkcie však nemajú prakticky žiadnu flexibilitu a obsahujú obrovské množstvo nedostatkov z hľadiska spracovania chýb atď. Okrem toho existujú určité úlohy, ktoré s týmito štandardnými funkciami jednoducho nemôžete vykonať: interakcia so súbormi cookie, overenie, odosielanie formulárov, nahrávanie súborov atď.

cURL je výkonná knižnica, ktorá podporuje mnoho rôznych protokolov, možností a poskytuje podrobné informácie o požiadavkách na adresy URL.

Základná štruktúra

• Inicializácia
• Priradenie parametrov
• Vykonanie a načítanie výsledku
• Uvoľnenie pamäte

// 1. inicializácia $ch = curl_init(); // 2. špecifikujte parametre vrátane url curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. získajte HTML ako výsledok $output = curl_exec($ch); // 4. zatvorte spojenie curl_close($ch);

Krok č. 2 (t. j. volanie curl_setopt()) bude v tomto článku diskutovaný oveľa viac ako všetky ostatné kroky, pretože V tejto fáze sa dejú všetky najzaujímavejšie a najužitočnejšie veci, ktoré potrebujete vedieť. V cURL existuje veľké množstvo rôznych možností, ktoré musia byť špecifikované, aby bolo možné nakonfigurovať požiadavku na URL tým najopatrnejším spôsobom. Nebudeme sa zaoberať celým zoznamom, ale zameriame sa len na to, čo považujem za potrebné a užitočné pre túto lekciu. Všetko ostatné si môžete naštudovať sami, ak vás táto téma zaujíma.

Kontrola chýb

Okrem toho môžete použiť aj podmienené príkazy na testovanie, či sa operácia úspešne dokončila:

// ... $output = curl_exec($ch); if ($output === FALSE) ( echo "cURL Error: " . curl_error($ch); ) // ...

Tu vás žiadam, aby ste si všimli veľmi dôležitý bod: na porovnanie musíme použiť „=== nepravda“ namiesto „== nepravda“. Pre tých, ktorí to nevedia, nám to pomôže rozlíšiť medzi prázdnym výsledkom a boolovskou hodnotou false, čo bude indikovať chybu.

Získavanie informácií

Ďalším dodatočným krokom je získanie údajov o požiadavke cURL po jej vykonaní.

// ... curl_exec($ch); $info = curl_getinfo($ch); echo "Vzala". $info["total_time"] . "sekundy pre url". $info["url"]; //…

Vrátené pole obsahuje nasledujúce informácie:

• "url"
• "typ_obsahu"
• "http_code"
• "veľkosť_hlavičky"
• "veľkosť_žiadosti"
• "filetime"
• "ssl_verify_result"
• "redirect_count"
• „celkový_čas“
• "namelookup_time"
• "connect_time"
• "čas pred transferom"
• „veľkosť_nahrávania“
• "size_download"
• "speed_download"
• "speed_upload"
• „dĺžka_obsahu na stiahnutie“
• dĺžka_nahrávaného_obsahu
• "starttransfer_time"
• „čas_presmerovania“

Detekcia presmerovania v závislosti od prehliadača

V tomto prvom príklade napíšeme kód, ktorý dokáže rozpoznať presmerovania adries URL na základe rôznych nastavení prehliadača. Niektoré webové stránky napríklad presmerujú prehliadače mobilného telefónu alebo akéhokoľvek iného zariadenia.

Na definovanie odchádzajúcich hlavičiek HTTP použijeme možnosť CURLOPT_HTTPHEADER vrátane názvu prehliadača používateľa a dostupných jazykov. Nakoniec budeme môcť určiť, ktoré stránky nás presmerujú na rôzne adresy URL.

// otestujte URL $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // testovanie prehliadačov $browsers = array("standard" => 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" => pole ("user_agent" => "Mozilla/5.0 (iPhone; U ; CPU ako Mac OS X sk) AppleWebKit/420+ (KHTML, ako Gecko) verzia/3.0 Mobile/1A537a Safari/419.3", "language" => "en"), "francúzština" => pole ("user_agent"; => "Mozilla/4.0 (kompatibilné; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "jazyk" => "fr,fr-FR;q=0.5")); foreach ($urls ako $url) ( echo "URL: $url\n"; foreach ($browsers ako $test_name => $browser) ( $ch = curl_init(); // špecifikujte webovú adresu curl_setopt($ch, CURLOPT_URL , $url // špecifikujte hlavičky pre prehliadač curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["jazyk"]); )" )); // nepotrebujeme obsah stránky curl_setopt($ch, CURLOPT_NOBODY, 1); // potrebujeme získať hlavičky HTTP curl_setopt($ch, CURLOPT_HEADER, 1); // namiesto výstupu vráti výsledky curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); $output = curl_exec($ch); , $zhody) ( echo " $test_name: presmeruje na $zhody\n"; ) else ( echo "$test_name: žiadne presmerovanie\n"; ) ) echo "\n\n" )

Najprv zadáme zoznam adries URL stránok, ktoré budeme kontrolovať. Presnejšie, potrebujeme adresy týchto stránok. Ďalej musíme definovať nastavenia prehliadača na testovanie každej z týchto adries URL. Potom použijeme slučku, v ktorej prejdeme všetky získané výsledky.

Trik, ktorý v tomto príklade používame na nastavenie nastavení cURL, nám umožní získať nie obsah stránky, ale iba hlavičky HTTP (uložené v $output). Ďalej pomocou jednoduchého regulárneho výrazu môžeme určiť, či sa v prijatých hlavičkách nachádza reťazec „Umiestnenie:“.

Keď spustíte tento kód, mali by ste dostať niečo takéto:

Vytvorenie požiadavky POST na konkrétnu adresu URL

Pri vytváraní požiadavky GET môžu byť prenášané údaje odovzdané URL prostredníctvom „reťazca dopytu“. Keď napríklad vyhľadávate v službe Google, hľadaný výraz sa umiestni do panela s adresou novej adresy URL:

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

Na simuláciu tejto požiadavky nemusíte použiť cURL. Ak vás lenivosť úplne premôže, na získanie výsledku použite funkciu „file_get_contents()“.

Ide však o to, že niektoré formuláre HTML odosielajú požiadavky POST. Údaje týchto formulárov sa prenášajú cez telo HTTP požiadavky a nie ako v predchádzajúcom prípade. Ak ste napríklad vyplnili formulár na fóre a klikli na tlačidlo vyhľadávania, s najväčšou pravdepodobnosťou sa odošle žiadosť POST:

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

Môžeme napísať PHP skript, ktorý dokáže simulovať tento druh URL požiadavky. Najprv vytvorte jednoduchý súbor na prijatie a zobrazenie údajov POST. Nazvime to post_output.php:

Print_r($_POST);

Potom vytvoríme PHP skript na vytvorenie požiadavky cURL:

$url = "http://localhost/post_output.php"; $post_data = pole ("foo" => "bar", "query" => "Nettuts", "action" => "Odoslať"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // indikuje, že máme požiadavku POST curl_setopt($ch, CURLOPT_POST, 1); // pridanie premenných curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close($ch); echo $výstup;

Keď spustíte tento skript, mali by ste dostať takýto výsledok:

Požiadavka POST bola teda odoslaná skriptu post_output.php, ktorý následne vypíše superglobálne pole $_POST, ktorého obsah sme získali pomocou cURL.

Nahrávanie súboru

Najprv vytvorte súbor, aby sme ho vygenerovali a odošlite ho do súboru upload_output.php:

Print_r($_FILES);

A tu je kód skriptu, ktorý vykonáva vyššie uvedené funkcie:

$url = "http://localhost/upload_output.php"; $post_data = pole ("foo" => "bar", // súbor na nahranie "nahrať" => "@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); echo $výstup;

Keď chcete nahrať súbor, všetko, čo musíte urobiť, je odovzdať ho ako normálnu premennú príspevku, pred ktorou bude symbol @. Keď spustíte skript, ktorý ste napísali, dostanete nasledujúci výsledok:

Viaceré cURL

Jednou z najväčších predností cURL je schopnosť vytvárať „viaceré“ obslužné programy cURL. To vám umožní otvoriť pripojenie k viacerým URL súčasne a asynchrónne.

V klasickej verzii požiadavky cURL je vykonávanie skriptu pozastavené a operácia URL požiadavky čaká na dokončenie, po ktorom môže skript pokračovať v behu. Ak máte v úmysle interagovať s celým radom adries URL, povedie to k značnej investícii času, pretože v klasickej verzii môžete naraz pracovať iba s jednou adresou URL. Túto situáciu však môžeme napraviť pomocou špeciálnych handlerov.

Pozrime sa na príklad kódu, ktorý som prevzal z php.net:

// vytvorenie niekoľkých zdrojov cURL $ch1 = curl_init(); $ch2 = curl_init(); // špecifikujte URL a ďalšie parametre 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); //vytvor viacnásobnú obsluhu cURL $mh = curl_multi_init(); //pridanie niekoľkých handlerov curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $aktívny = null; //vykonaj do ( $mrc ​​​​= curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc ​​​​== CURLM_OK) ( if (curl_multi_select($mh) != -1) ( do ( $mrc ​​​​= curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);

Myšlienka je, že môžete použiť viacero obslužných programov cURL. Pomocou jednoduchej slučky môžete sledovať, ktoré požiadavky ešte neboli dokončené.

V tomto príklade sú dve hlavné slučky. Prvá slučka do-while volá curl_multi_exec(). Táto funkcia nie je blokovateľná. Beží čo najrýchlejšie a vracia stav požiadavky. Pokiaľ je vrátená hodnota konštanta 'CURLM_CALL_MULTI_PERFORM', znamená to, že práca ešte nie je dokončená (napríklad hlavičky http sa momentálne odosielajú na adresu URL); Preto túto návratovú hodnotu stále kontrolujeme, kým nedosiahneme iný výsledok.

V ďalšej slučke skontrolujeme podmienku, kým premenná $active = "true". Je to druhý parameter funkcie curl_multi_exec(). Hodnota tejto premennej bude „true“, pokiaľ budú aktívne niektoré z existujúcich zmien. Ďalej zavoláme funkciu curl_multi_select(). Jeho vykonávanie je „zablokované“, kým je aktívne aspoň jedno pripojenie, kým nedostane odpoveď. Keď sa to stane, vrátime sa do hlavnej slučky, aby sme pokračovali vo vykonávaní dotazov.

Teraz aplikujme to, čo sme sa naučili, na príklade, ktorý bude naozaj užitočný pre veľa ľudí.

Kontrola odkazov vo WordPress

Predstavte si blog s obrovským množstvom príspevkov a správ, z ktorých každý obsahuje odkazy na externé internetové zdroje. Niektoré z týchto odkazov už môžu byť z rôznych dôvodov mŕtve. Stránka mohla byť odstránená alebo stránka nemusí vôbec fungovať.

Vytvoríme skript, ktorý analyzuje všetky odkazy a nájde nenačítavacie webové stránky a 404 stránok a následne nám poskytne podrobnú správu.

Hneď poviem, že toto nie je príklad vytvorenia pluginu pre WordPress. Toto je absolútne dobré testovacie miesto pre naše testy.

Začnime konečne. Najprv musíme získať všetky odkazy z databázy:

// konfigurácia $db_host = "localhost"; $db_user = "root"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = array("localhost", "www.mydomain.com"); $max_connections = 10; // inicializácia premenných $url_list = array(); $working_urls = array(); $dead_urls = pole(); $not_found_urls = array(); $aktívny = null; // pripojenie k MySQL if (!mysql_connect($db_host, $db_user, $db_pass)) ( die("Nedá sa pripojiť: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("Mohol by sa pripojiť nevyberať db: " . mysql_error()); ) // vybrať všetky publikované príspevky s odkazmi $q = "VYBERTE obsah_príspevku FROM wp_posts KDE post_content LIKE "%href=%" AND post_status = "publikovať" AND post_type = "príspevok "" ; $r = mysql_query($q) or die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // načítanie odkazov pomocou regulárnych výrazov if (preg_match_all("!href=\"(.*?)\"!", $d["post_content"], $ sa zhoduje) ) ( foreach ($zodpovedá $url) ( $tmp = parse_url($url); if (in_array($tmp["hostiteľ"], $excluded_domains)) (pokračovať; ) $url_list = $url; ) ) ) / / odstránenie duplikátov $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die("Žiadna adresa URL na kontrolu"); )

Najprv vygenerujeme konfiguračné údaje pre interakciu s databázou, následne napíšeme zoznam domén, ktoré sa kontroly nezúčastnia ($excluded_domains). Definujeme tiež číslo charakterizujúce počet maximálnych súčasných spojení, ktoré použijeme v našom skripte ($max_connections). Potom sa pripojíme k databáze, vyberieme príspevky, ktoré obsahujú odkazy, a zhromažďujeme ich do poľa ($url_list).

Nasledujúci kód je trochu komplikovaný, takže si ho prejdite od začiatku do konca:

// 1. viacnásobná obsluha $mh = curl_multi_init(); // 2. pridajte množinu adries URL pre ($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; } }

Tu sa pokúsim všetko podrobne vysvetliť. Čísla v zozname zodpovedajú číslam v komentári.

1. 1. Vytvorte viacnásobnú obsluhu;
2. 2. Funkciu add_url_to_multi_handle() napíšeme o niečo neskôr. Zakaždým, keď sa zavolá, začne spracovanie novej adresy URL. Na začiatok pridáme 10 ($max_connections) adries URL;
3. 3. Aby sme mohli začať, musíme spustiť funkciu curl_multi_exec(). Kým vráti CURLM_CALL_MULTI_PERFORM, stále máme čo robiť. Potrebujeme to hlavne na vytváranie spojení;
4. 4. Nasleduje hlavná slučka, ktorá bude prebiehať dovtedy, kým budeme mať aspoň jedno aktívne spojenie;
5. 5. curl_multi_select() zamrzne a čaká na dokončenie vyhľadávania URL;
6. 6. Ešte raz musíme prinútiť cURL, aby vykonal nejakú prácu, konkrétne načítal údaje o odpovedi na návrat;
7. 7. Tu sa overujú informácie. V dôsledku vykonania požiadavky sa vráti pole;
8. 8. Vrátené pole obsahuje obsluhu cURL. Použijeme ho na výber informácií o samostatnej požiadavke cURL;
9. 9. Ak bol odkaz mŕtvy alebo vypršal časový limit skriptu, potom by sme nemali hľadať žiadny http kód;
10. 10. Ak nám odkaz vrátil stránku 404, potom kód http bude obsahovať hodnotu 404;
11. 11. Inak máme pred sebou fungujúci odkaz. (Môžete pridať ďalšie kontroly na kód chyby 500 atď...);
12. 12. Ďalej odstránime obsluhu cURL, pretože ju už nepotrebujeme;
13. 13. Teraz môžeme pridať ďalšiu adresu URL a spustiť všetko, o čom sme hovorili predtým;
14. 14. V tomto kroku skript dokončí svoju prácu. Môžeme odstrániť všetko, čo nepotrebujeme, a vygenerovať správu;
15. 15. Nakoniec napíšeme funkciu, ktorá pridá url do handlera. Statická premenná $index sa zvýši pri každom volaní tejto funkcie.

Použil som tento skript na svojom blogu (s niekoľkými nefunkčnými odkazmi, ktoré som pridal zámerne, aby som ho otestoval) a dostal som nasledujúci výsledok:

V mojom prípade skriptu trvalo prehľadávanie 40 adries URL o niečo menej ako 2 sekundy. Zvýšenie výkonu je výrazné pri práci s ešte väčším počtom adries URL. Ak otvoríte desať spojení súčasne, skript sa môže spustiť desaťkrát rýchlejšie.

Niekoľko slov o ďalších užitočných možnostiach cURL

HTTP autentifikácia

Ak má adresa URL overenie HTTP, môžete jednoducho použiť nasledujúci skript:

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // zadajte meno používateľa a heslo curl_setopt($ch, CURLOPT_USERPWD, "mojepoužívateľské meno:mojeheslo"); // ak je povolené presmerovanie curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // potom uložte naše údaje do cURL curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close($ch);

Nahrávanie cez FTP

PHP má tiež knižnicu na prácu s FTP, ale tu vám nič nebráni použiť nástroje cURL:

// otvorenie súboru $file = fopen("/cesta/k/suboru", "r"); // adresa URL by mala obsahovať nasledujúci obsah $url = "ftp://username: [e-mail chránený]:21/cesta/k/novemu/suboru"; $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($ch, CURLOPT_INFILESIZE, veľkosť súboru("/cesta/k/súboru") // špecifikácia režimu ASCII curl_setopt($ch, CURLOPT_FTPASCII, 1); ); curl_close($ch);

Použitie proxy

Žiadosť o adresu URL môžete vykonať prostredníctvom servera proxy:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // zadajte adresu curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // ak potrebujete zadať používateľské meno a heslo curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $output = curl_exec($ch); curl_close($ch);

Funkcie spätného volania

Je tiež možné určiť funkciu, ktorá sa spustí ešte pred dokončením požiadavky cURL. Napríklad počas načítavania obsahu odpovede môžete začať používať údaje bez toho, aby ste čakali na ich úplné načítanie.

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://net.tutsplus.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"funkcia_progresu"); curl_exec($ch); curl_close($ch); function progress_function($ch,$str) ( echo $str; return strlen($str); )

Takáto funkcia MUSÍ vrátiť dĺžku reťazca, čo je požiadavka.

Záver

Dnes sme sa naučili, ako môžete použiť knižnicu cURL na svoje sebecké účely. Dúfam, že sa vám tento článok páčil.

dakujem! Prajem pekný deň!