Comment mettre en cache la page PHP dynamique

Question

Comment mettre en cache la page PHP qui a une requête mysql. Tout exemple sera génial et utile.

Answer 1

memcache votre code html et ensuite faire quelque chose comme ceci:

$memcache = memcache_connect('localhost', 11211); 

$page = $memcache->get('homepage'); 
if($page == ""){ 
    $mtime = microtime(); 
    $page = get_home(); 
    $mtime = explode(" ",$mtime); 
    $mtime = $mtime[1] + $mtime[0]; 
    $endtime = $mtime; 
    $totaltime = ($endtime - $starttime); 
    memcache_set($memcache, 'homepage', $page, 0, 30); 
    $page .= "\n<!-- Duly stored ($totaltime) -->"; 
} 
else{ 
    $mtime = microtime(); 
    $mtime = explode(" ",$mtime); 
    $mtime = $mtime[1] + $mtime[0]; 
    $endtime = $mtime; 
    $totaltime = ($endtime - $starttime); 
    $page .= "\n&lt;!-- served from memcache ($totaltime) -->"; 
} 
die($page); 

Answer 2

Ma préférence est d'utiliser un proxy inverse de la mise en cache, comme Varnish.

En ce qui concerne une solution PHP pure, vous pouvez avoir du code à la fin de votre script qui met en cache la sortie finale, et du code au début qui vérifie si la page est mise en cache. Si la page a été trouvée dans le cache, envoyez-la et quittez plutôt que de réexécuter les requêtes.

<?php 

function cache_file() { 
    // something to (hopefully) uniquely identify the resource 
    $cache_key = md5($_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] . $_SERVER['QUERY_STRING']); 
    $cache_dir = '/tmp/phpcache'; 

    return $cache_dir . '/' . $cache_key; 
} 

// if we have a cache file, deliver it 
if(is_file($cache_file = cache_file())) { 
    readfile($cache_file); 
    exit; 
} 

// cache via output buffering, with callback 
ob_start('cache_output'); 

// 
// expensive processing happens here, along with page output. 
// 

function cache_output($content) { 
    file_put_contents(cache_file(), $content); 
    return $content; 
} 

Évidemment, cela a besoin de beaucoup de personnalisation pour votre configuration, y compris l'expiration du cache, un $cache_key qui répond à vos besoins, et la détection des pages d'erreur si mauvais ne sont pas mises en cache.

Answer 3

J'utilise phpFastCache (pour l'hébergement partagé, si vous ne voulez pas toucher php.ini et root pour configurer memcached). Consultez le menu Exemple. Ils ont un exemple détaillé, et très facile.

D'abord vous définissez avec phpFastCache :: set, puis obtenez avec phpFastCache :: get - DONE!

Exemple: Réduire la base de données Appels

Votre site ont 10.000 visiteurs qui sont en ligne, et votre page dynamique doivent envoyer 10.000 mêmes requêtes à la base de données sur chaque chargement de page. Avec phpFastCache, votre page n'envoie qu'une seule requête à la base de données et utilise le cache pour servir 9999 autres visiteurs.

<?php 
    // In your config file 
    include("php_fast_cache.php"); 
    phpFastCache::$storage = "auto"; 
    // you can set it to files, apc, memcache, memcached, pdo, or wincache 
    // I like auto 

    // In your Class, Functions, PHP Pages 
    // try to get from Cache first. 
    $products = phpFastCache::get("products_page"); 

    if($products == null) { 
     $products = YOUR DB QUERIES || GET_PRODUCTS_FUNCTION; 
     // set products in to cache in 600 seconds = 5 minutes 
     phpFastCache::set("products_page",$products,600); 
    } 

    OUTPUT or RETURN your $products 
?> 

Answer 4

<?php 
    //settings 
    $cache_ext = '.html'; //file extension 
    $cache_time  = 3600; //Cache file expires afere these seconds (1 hour = 3600 sec) 
    $cache_folder = 'cache/'; //folder to store Cache files 
    $ignore_pages = array('', ''); 

    $dynamic_url = 'http://'.$_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] . $_SERVER['QUERY_STRING']; // requested dynamic page (full url) 
    $cache_file  = $cache_folder.md5($dynamic_url).$cache_ext; // construct a cache file 
    $ignore = (in_array($dynamic_url,$ignore_pages))?true:false; //check if url is in ignore list 

    if (!$ignore && file_exists($cache_file) && time() - $cache_time < filemtime($cache_file)) { //check Cache exist and it's not expired. 
     ob_start('ob_gzhandler'); //Turn on output buffering, "ob_gzhandler" for the compressed page with gzip. 
     readfile($cache_file); //read Cache file 
     echo '<!-- cached page - '.date('l jS \of F Y h:i:s A', filemtime($cache_file)).', Page : '.$dynamic_url.' -->'; 
     ob_end_flush(); //Flush and turn off output buffering 
     exit(); //no need to proceed further, exit the flow. 
    } 
    //Turn on output buffering with gzip compression. 
    ob_start('ob_gzhandler'); 
    ######## Your Website Content Starts Below ######### 
    ?> 
    <!DOCTYPE html> 
    <html> 
     <head> 
      <title>Page to Cache</title> 
     </head> 
      <body> 
       Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer ut tellus libero. 
      </body> 
    </html> 
    <?php 
    ######## Your Website Content Ends here ######### 

    if (!is_dir($cache_folder)) { //create a new folder if we need to 
     mkdir($cache_folder); 
    } 
    if(!$ignore){ 
     $fp = fopen($cache_file, 'w'); //open file for writing 
     fwrite($fp, ob_get_contents()); //write contents of the output buffer in Cache file 
     fclose($fp); //Close file pointer 
    } 
    ob_end_flush(); //Flush and turn off output buffering 

    ?> 

Answer 5

L'important, souvent négligé quand il y a discussion sur la mise en cache, est la synchronisation de processus pour éviter la course de fil (voir: https://en.wikipedia.org/wiki/Race_condition).

Un scénario de mise en cache typique en PHP sans synchronisation ressemble à ceci: si vous n'avez pas de ressource dans le cache, ou que la ressource a expiré, elle doit être créée et mise en cache. Le premier thread/processus qui arrive à rencontrer une telle condition essaie de créer une ressource, et pendant ce temps, d'autres threads créent également la ressource, ce qui conduit à une course de threads, à un claquement de cache et à une chute de performance.

Le problème est amplifié par le nombre de threads simultanés et la charge de travail créée par la tâche de création de ressource. Sur les systèmes occupés, cela peut entraîner de sérieux problèmes.

Il y a très peu de systèmes de cache pour PHP qui prennent en compte la synchronisation.

L'un d'eux est php-no-slam-cache: https://github.com/tztztztz/php-no-slam-cache