Récupérer du contenu pour vos pages

Aspirer une Page via PHP et cURL pour Éviter les IFrames

PHP le Lundi 19 avril 2010 Aucun commentaire

Aspirer une Page via PHP et cURL pour Éviter les IFrames

Si vous utilisez des services tiers vous pouvez être amenés à devoir intégrer du contenu en provenance d’autres sites dans vos pages. Le contenu est alors affiché dans des IFrames qui ont de nombreux inconvénients :

  • les moteurs de recherches ne peuvent pas indexer le contenu et suivre les liens,
  • le style n’est pas forcément modifiable,
  • cadre de taille fixe ne s’adaptant pas au contenu (il existe quand même des solutions pour ça).

Nous allons présenter ici une méthode pour récupérer le contenu d'une page web afin de l'intégrer à votre webpage. Avant toute picked vérifiez les conditions d'utilisation du benefit dont vous voulez récupérer du contenu afin d'être certain de rester en accord avec ses termes.

Utiliser cURL pour récupérer le contenu d’une page

libcurl est une librairie supporté depuis la form 4.0.2 de PHP qui permet de se connecter et de communiquer avec de très nombreux sorts de serveurs utilisant de nombreux sorts de protocoles. En voici la liste : http, https, ftp, gopher, telnet, dict, record, et protocoles ldap. Libcurl accepte également les certificats HTTPS, HTTP POST, HTTP PUT, téléchargement FTP, téléchargements basés sur des formulaires HTTP, intermediaries, treats, et authentification standard nom d'utilisateur et saying de old fashioned.

Twist peut ainsi vous permettre de récupérer du contenu en utilisant PHP dans de très nombreuses conditions.

Une classe PHP pour utiliser cURL

La façon la plus efficace de rajouter de nouvelles fonctionnalités à vos scripts PHP est d’utiliser une classe.  Je ne vais pas ré-inventer la roue. De nombreux développeurs ont déjà travaillés sur cURL et ses possibilités. Sur la page de cURL sur le site de PHP  on trouve un script pour PHP 5, qui après une petite correction est :

[php]
<?php
class mycurl {
protected $_useragent = ‘Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1′;
protected $_url;
protected $_followlocation;
protected $_timeout;
protected $_maxRedirects;
protected $_cookieFileLocation = ‘./cookie.txt’;
protected $_post;
protected $_postFields;
protected $_referer ="http://www.google.com";

protected $_session;
protected $_webpage;
protected $_includeHeader;
protected $_noBody;
protected $_status;
protected $_binaryTransfer;
public $authentication = 0;
public $auth_name =  »;
public $auth_pass =  »;

public function useAuth($use){
$this->authentication = 0;
if($use == true) $this->authentication = 1;
}

public function setName($name){
$this->auth_name = $name;
}
public function setPass($pass){
$this->auth_pass = $pass;
}

public function __construct($url = "",$followlocation = true,$timeOut = 30,$maxRedirecs = 4,$binaryTransfer = false,$includeHeader = false,$noBody = false)
{
$this->_url = $url;
$this->_followlocation = $followlocation;
$this->_timeout = $timeOut;
$this->_maxRedirects = $maxRedirecs;
$this->_noBody = $noBody;
$this->_includeHeader = $includeHeader;
$this->_binaryTransfer = $binaryTransfer;

$this->_cookieFileLocation = dirname(__FILE__).’/cookie.txt’;

}

public function setReferer($referer){
$this->_referer = $referer;
}

public function setCookiFileLocation($path)
{
$this->_cookieFileLocation = $path;
}

public function setPost ($postFields)
{
$this->_post = true;
$this->_postFields = $postFields;
}

public function setUserAgent($userAgent)
{
$this->_useragent = $userAgent;
}

public function createCurl($url = ‘nul’)
{
if($url != ‘nul’){
$this->_url = $url;
}

$s = curl_init();

curl_setopt($s,CURLOPT_URL,$this->_url);
curl_setopt($s,CURLOPT_HTTPHEADER,array(‘Expect:’));
curl_setopt($s,CURLOPT_TIMEOUT,$this->_timeout);
curl_setopt($s,CURLOPT_MAXREDIRS,$this->_maxRedirects);
curl_setopt($s,CURLOPT_RETURNTRANSFER,true);
curl_setopt($s,CURLOPT_FOLLOWLOCATION,$this->_followlocation);
curl_setopt($s,CURLOPT_COOKIEJAR,$this->_cookieFileLocation);
curl_setopt($s,CURLOPT_COOKIEFILE,$this->_cookieFileLocation);

if($this->authentication == 1){
curl_setopt($s, CURLOPT_USERPWD, $this->auth_name.’:’.$this->auth_pass);
}
if($this->_post)
{
curl_setopt($s,CURLOPT_POST,true);
curl_setopt($s,CURLOPT_POSTFIELDS,$this->_postFields);

}

if($this->_includeHeader)
{
curl_setopt($s,CURLOPT_HEADER,true);
}

if($this->_noBody)
{
curl_setopt($s,CURLOPT_NOBODY,true);
}
/*
if($this->_binary)
{
curl_setopt($s,CURLOPT_BINARYTRANSFER,true);
}
*/
curl_setopt($s,CURLOPT_USERAGENT,$this->_useragent);
curl_setopt($s,CURLOPT_REFERER,$this->_referer);

$this->_webpage = curl_exec($s);
$this->_status = curl_getinfo($s,CURLINFO_HTTP_CODE);
curl_close($s);

}

public function getHttpStatus()
{
return $this->_status;
}

public function __tostring(){
return $this->_webpage;
}
}
?>
[/php]

Maintenant que nous avons le moteur qui va nous permettre de récupérer le contenu de notre page. Mais le contenu de celui-ci pouvant être sensiblement le même on limitera le nombre de requêtes en utilisant un cache.

Une classe PHP pour gérer le cache

Récupérer un contenu pour l’afficher sur votre site peut ralentir l’affichage de votre page. De nombreuses étapes sont à franchir :

  • Délais du ping du serveur lors de la requête.
  • Délais d’affichage de la page par le serveur,
  • Délais de la récupération de la page par cURL
  • Délais des traitements de la page pour récupérer le contenu.

Utiliser un cache évitera toutes ces étapes. sa durée est appréciable suivant le taux de rafraichissement du contenu à récupérer. Afin de gérer ce cache nous allons utiliser la classe PHP suivante :

[php]
<?php
class Cacher {
// Written by Serge Stepanov
var $cacheDir = "/tmp/";
var $defaultCacheLife = "3600";

function Set($varId, $varValue) {
$this->Delete($varId);
$fileHandler = fopen($this->cacheDir . "cache." . $varId . "." . time(), "a");
fwrite($fileHandler, serialize($varValue));
fclose($fileHandler);
}

function Get($varId, $cacheLife="") {
$cacheLife = (!empty($cacheLife)) ? $cacheLife : $this->defaultCacheLife;

$dirHandler = dir($this->cacheDir);
while ($file = $dirHandler->read()) {
if (preg_match("/cache.$varId.[0-9]/", $file)) {
$cacheFileName = explode(".", $file);
$cacheFileLife = $cacheFileName[2];
$cacheFile = $this->cacheDir . $file;

if ((time() – $cacheFileLife) < $cacheLife) {
$fileHandler = fopen($cacheFile, "r");
$varValueResult = fread($fileHandler, filesize($cacheFile));
fclose($fileHandler);
return unserialize($varValueResult);
} else {
break;
}
}
}
$dirHandler->close();
return FALSE;
}

function Delete($varId) {
$dirHandler = dir($this->cacheDir);
while ($file = $dirHandler->read()) {
if (preg_match("/cache.$varId.[0-9]/", $file)) {
unlink($this->cacheDir . $file);
}
}
$dirHandler->close();
}

}
?>
[/php]

Nous avons maintenant tous les outils qui nous permettrons de récupérer le contenu de la page.

Récupérer et afficher le contenu de la page qui nous intéresse

Nous allons voir ici seulement le cas de la récupération du contenu situé entre les balises <body></body> d’une page XHTML standard sur un serveur HTTP. Utilisez les commentaires du script afin de le moduler suivant vos besoins :

[php]
<?php
// On prépare le cache
$cache = new Cacher;
// On met le cache à 60 secondes
$page_content = $cache->Get("page_content", 60);

if (!$page_content) {
// Le fichier cache a expiré ou est inexistant
// Nous allons récupérer les données

// Définissons l’url que l’on veut récupérer
$url_to_grab = "http://www.news.google.fr";

// on réveille la classe
$foo=new mycurl();

// on lui explique comment on veut les choses
$foo->__construct(
// l’url
$url_to_grab,
// est ce que l’on suit l’adresse? OUI = true
true,
// après combien de temps sans réponse doit on laisser tomber ? 30 secondes
30,
// nombre maximum de redirections suivi, ici 4
4,
// transfert en mode binaire, si NON = false alors le transfert se fait en mode ASCII (c’est pour certains FTP)
false,
// on veut récupérer l’entête HTTP, NON = false alors on aura la page
false,
// on ne veut pas le corp de la page, NON = false alors on aura la page
false
);

// Emplacement du cookie sur votre site.
// Si vous êtes dans le cas d’utilisations multi-sessions, donc multi-coookies :
// vous devrez alors développer pour avoir des cookies uniques suivant les utilisateurs
// et peut être supprimer le cache.
$foo->setCookiFileLocation(dirname(__FILE__).’/cookie.txt’);
// On indique ici au serveur que l’on visite que l’on arrive de google.
// Mettez ce que vous voulez, l’adresse de votre site est la solution la plus honnête.
$foo->setReferer("http://www.google.com");
// On indique ici au serveur que l’on utilise Firefox 6.3.2 en français sur Windows.
// Mettez ce que vous voulez, "PHP 5" serait la solution la plus honnête.
$foo->setUserAgent("Mozilla/5.0 (Windows; U; Windows NT 6.0; fr-FR; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 (.NET CLR 3.5.30729)");
// Le script récupère le contenu de la page.
$foo->createCurl($url_to_grab);

// on peut alors manipuler le contenu comme on veut en utilisant :
// preg_filter, preg_match, preg_replace…
// Pour vous aider avec les expressions régulières vous pouvez visiter http://www.regexlib.com/

// On récupère la partie de la page qui nous intéresse
// Dans notre cas on récupère le contenu qui de trouve dans la balise <body>
preg_match("/<body.*\/body>/s", $foo->__tostring(), $page_content);
$page_content = $page_content[0];
// on supprime les balises <body>
$page_content = str_replace(‘<body>’,  », $page_content);
$page_content = str_replace(‘</body>’,  », $page_content);

// On met le contenu dans le cache
$cache->Set("page_content", $page_content);
}

// On affiche le contenu
echo $page_content;
?>
[/php]

Vous pouvez utiliser plusieurs caches si vous récupérez différents éléments dans la page comme par exemple javascript + CSS + contenu. Éléments que vous allez appeler dans des emplacements différents de votre page.

Vous avez récupéré la page qui vous intéresse, vous en avez extrait le contenu, et il a été mis dans un cache que vous pouvez afficher. Vous voilà prêt à remplacer vos iframes par du contenu.

Téléchargez le script php pour aspirer le contenu d'une page


Tags : ,

Aucun commentaire pour “Aspirer une Page via PHP et cURL pour Éviter les IFrames”

Laissez un commentaire