Wie werden schwere Operationen (z. B. Datenbankabfragen) in PHP zwischengespeichert?

PHP ist eine sehr beliebte Programmiersprache für das Web. Es ist eine praktische und leistungsstarke, locker typisierte Programmiersprache, die Sie innerhalb kurzer Zeit erlernen und verwenden können. Es wird so weit verbreitet und beliebt, vielleicht dank WordPress, einem Blogging- oder CMS (Content Management System). Viele Websites wie Facebook basieren ursprünglich auf PHP.

Allerdings wird PHP im Allgemeinen als eine langsam interpretierende Skriptsprache betrachtet, obwohl es viele Techniken gibt, um sie zu beschleunigen, z. B. standardmäßig installierter Zend Optimizer. Die HHVM hilft, das PHP zur Laufzeit in so etwas wie Bytecode zu kompilieren, der dann in nativen Code übersetzt werden kann, was die Leistung verbessert.

Datenbankabfragen sind zeitaufwändig, insbesondere bei großen Tabellen oder Tabellen ohne ordnungsgemäße Indizierung. Manchmal verlangsamen solche Vorgänge die Seitenlade-/Verarbeitungsgeschwindigkeit und beeinträchtigen dann die Benutzererfahrung. Sehr oft dauert es einige Zeit, bis solche Abfragen abgeschlossen sind, aber die Ergebnisse ändern sich nicht so häufig, dh sie werden vielleicht einmal am Tag geändert. In diesem Fall ist es besser, diese Ergebnisse in Dateien zwischenzuspeichern und sie beim nächsten Mal beim Lesen der Dateien zu erhalten, wenn sie bereits im Cache gefunden werden.

Die MySQL-Datenbank ist gut darin, Abfragen mit richtiger Indizierung zu verarbeiten. Wenn die Tabelle jedoch groß wird, wirkt sich dies irgendwie auf die Leistung aus. Wir können alle rechenintensiven Operationen zwischenspeichern und in Dateien auf Festplatten speichern und beim nächsten Mal direkt aus den Dateien lesen, was viel schneller ist.

Wir haben eine PHP-Klasse bereitgestellt, die einfach in Ihre Anwendung eingebunden werden kann.

class Cache {
    private $folder = '';
    
    // constructor takes an optional path for storing the cache files
    public function __construct($path = '') {
        $path = trim($path);
        if ((strlen($path) && is_dir($path))) {
            $this->setFolder($path);
        } else {
            $this->setFolder('/tmp/');   // tmp folder if empty
        }
    }
    
    public function getFolder() {
        return $this->folder;  
    }    
    
    public function setFolder($path) {
        $path = trim($path);
        $len = strlen($path);
        if ($len) {
            if (is_dir($path)) {
                if ($path[$len - 1] != '/') {
                  $path .= '/';  // adds a forward slashes at the end
                }  
                $this->folder = $path;
            }
        }
    }
 
    // read from caches, if not found, return null
    public function read($fileName) {
        $fileName = $this->folder.$fileName;
        if (is_file($fileName)) {
            $handle = fopen($fileName, 'rb'); // open as binary
            $variable = fread($handle, filesize($fileName));
            fclose($handle);
            return unserialize($variable);
        } else {
            return null;
        }
    }
     
    // write $variable to $fileName
    public function write($fileName, $variable) {
        $fileName = $this->folder.$fileName;
        $handle = fopen($fileName, 'a');
        fwrite($handle, serialize($variable));
        fclose($handle);
    }
     
    // delete cache entry $fileName
    public function delete($fileName) {
        $fileName = $this->folder.$fileName;
        @unlink($fileName);  // put a @ to avoid file-not-found warning
    }
}

Die Kommentare stehen also. Die obige Klasse ist unkompliziert und einfach zu verwenden. Zum Beispiel habe ich Folgendes verwendet, um eine Abfrage für meine Website zwischenzuspeichern.

    require('class.cache.php');
    $cache = new Cache('cache/1/');
    $entry = md5($url);
    $data = $cache->read($entry);
    $blogtitle = "";
    if ($data !== null) { // found cache
          $blogtitle = $data; // read the data
    } else {
      $query = "select `title` from `blog` where `path`='$url'";
      $result = mysql_query($query, $link);
 
      if (mysql_num_rows($result))
      {
              $blogtitle = mysql_result($result, 0, 0);
      } 
      $cache->write($entry, $blogtitle);  // save the cache for next read 
    }

Wenn wir also den Cache löschen möchten, können wir ihn einfach löschen, indem wir:

    // suppose we run here the query ("update `blog` set `title` = 'test' where `path` = '$url'");
    require('class.cache.php');
    $cache = new Cache('cache/1/');
    $entry = md5($url);
    $cache->delete($entry);

Das Online-CURL-Header-Anforderungstool verwendet diese Cache-Technik, um die CPU-Last des Webservers zu reduzieren, und diese Cache-Dateien werden alle paar Tage gelöscht, um eine Überlastung des Speicherplatzes auf dem Webserver zu verhindern.

Denken Sie daran, dass die Seitenladegeschwindigkeit einer der Faktoren ist, die Ihren SEO-Score beeinflussen. Suchmaschinen bevorzugen schnellere Websites.