Welche Cache-Typen gibt es bei thinkphp?

ThinkPHP bietet praktische Caching-Methoden, einschließlich Daten-Caching, statisches Caching und Abfrage-Caching usw. Die Unterstützung umfasst Dateimodus, APC, Db, Memcache, Shmop, Dynamic Daten-Cache-Typen wie Sqlite, Redis, Eaccelerator und Xcache sowie anpassbare statische Cache-Regeln bieten Verknüpfungsmethoden für Zugriffsvorgänge.

Daten-Cache

Thinkphp-Cache-Dateikonfiguration

Home ist das Front-End-Projekt, das ich in HomeConfconfig.php erstellt habe Konfigurieren Sie es wie folgt:

<?php   
   return array(       
   &#39;DB_TYPE&#39;=>&#39;mysql&#39;,       
   &#39;DB_HOST&#39;=>&#39;127.0.0.1&#39;,       
  &#39;DB_NAME&#39;=>&#39;w3note&#39;,       
   &#39;DB_USER&#39;=>&#39;root&#39;,       
  &#39;DB_PWD&#39;=>&#39;123456&#39;,       
  &#39;DB_PORT&#39;=>&#39;3306&#39;,       
  &#39;DB_PREFIX&#39;=>&#39;w3_&#39;,       
  &#39;DATA_CACHE_TYPE&#39;=>&#39;file&#39;,//设置缓存方式为file       
  &#39;DATA_CACHE_TIME&#39;=>&#39;600&#39;,//缓存周期600秒       
 );       
 ?>

Verwendung der Thinkphp-Cache-Funktion

Verwenden Sie in thinkphp die Verknüpfungs-Cache-Funktion S() für das Caching:

S('data',$Data);//使用data标识缓存$Data数据  
S('data',$Data,600);// 缓存$Data数据600秒  
 $Data = S('data');// 获取缓存数据  
S('data',NULL);// 删除缓存数据

Beispieldemonstration

<?php       
 // 本类由系统自动生成，仅供测试用途       
  class IndexAction extends Action{       
    public function index(){       
        //如果有缓存，则读取缓存数据       
        //如果没有缓存，则读取数据库当中的数据放入缓存       
        $lists=S(&#39;lists&#39;);                     
        if(emptyempty($lists)){                           
          $news=M(&#39;news&#39;);   
          $lists=$news->select();   
          S(&#39;lists&#39;,$lists,600);   
          echo &#39;这是直接读取数据库的数据&#39;;       
           }   
        dump($list);  
 ?>

Besuchen Sie http://127.0.0.1/Home/index.php/Index/index,

Erster Besuch:

Dies dient zum direkten Lesen der Daten aus der Datenbank

array(10) {  
   [0] => array(12) {  
     ["id"] => string(1) "1"  
     ["catid"] => string(2) "13"  
     ["title"] => string(4) "thinkphp的缓存技术"  
     ["content"] => string(8) "thinkphp的缓存技术"  
     ["tags"] => string(4) "缓存"  
     ["thumb"] => string(0) ""  
     ["description"] => string(7) "thinkphp的缓存技术"  
     ["inputtime"] => string(10) "1348370202"  
     ["posid"] => string(1) "1"  
     ["ord"] => string(1) "2"  
     ["hits"] => string(1) "1"  
     ["status"] => string(1) "1"  
 }

Zweiter Besuch:

array(10) {  
   [0] => array(12) {  
     ["id"] => string(1) "1"  
     ["catid"] => string(2) "13"  
     ["title"] => string(4) "thinkphp的缓存技术"  
     ["content"] => string(8) "thinkphp的缓存技术"  
     ["tags"] => string(4) "缓存"  
     ["thumb"] => string(0) ""  
     ["description"] => string(7) "thinkphp的缓存技术"  
     ["inputtime"] => string(10) "1348370202"  
     ["posid"] => string(1) "1"  
     ["ord"] => string(1) "2"  
     ["hits"] => string(1) "1"  
     ["status"] => string(1) "1"  
 }

Hinweis: Beim ersten Ausführen werden die oben angezeigten Informationen gedruckt. Nach dem Aktualisieren der Seite wird kein „Das ist das“ angezeigt Daten werden direkt aus der Datenbank gelesen. Dies zeigt an, dass die zuvor generierten Cache-Daten gelesen werden.

Verwandte Empfehlungen: „ThinkPHP Tutorial“

Quick Cache

Wenn Sie nur einige Dateien zwischenspeichern möchten Daten und kein Konzept der Gültigkeitsdauer, das System bietet auch eine schnelle Caching-Methode F für schnellere Vorgänge.

Datendaten schnell zwischenspeichern und standardmäßig im Verzeichnis DATA_PATH speichern

F('data',$Data);

Datendaten schnell zwischenspeichern und im angegebenen Verzeichnis speichern

F('data',$Data,TEMP_PATH);

Zwischengespeicherte Daten abrufen

$Data = F('data');

Zwischengespeicherte Daten löschen

F('data',NULL);

F-Methode unterstützt die automatische Erstellung von Cache-Unterverzeichnissen und speichert Datendaten im Verzeichnis DATA_PATH zwischen. Wenn das Benutzerunterverzeichnis nicht vorhanden ist, wird es automatisch erstellt:

F('User/data',$Data);

Version 3.1.2 Die Start-F-Methode unterstützt die Stapellöschfunktion mit Platzhalterzeichen. Verwenden Sie Folgendes:

F('User/*',NULL);

bedeutet, den Datencache im Verzeichnis DATA_PATH.'User/' zu löschen.

Der integrierte Datenfeld-Informationscache des Systems verwendet einen schnellen Caching-Mechanismus.

Abfrage-Cache

Für Datenabfragen, die keine hohe Aktualität erfordern, können wir die Abfrage-Cache-Funktion verwenden, um die Leistung zu verbessern, und es besteht keine Notwendigkeit, Caching-Methoden zu verwenden zum Zwischenspeichern und Abrufen.

APP/config.php-Konfiguration:

'DATA_CACHE_TIME'   => 60, // 数据缓存有效期 0表示永久缓存
'DATA_CACHE_TYPE'   => 'File',
 // 数据缓存类型,支持:File|Db|Apc|Memcache|Shmop|Sqlite|Xcache|Apachenote|Eaccelerator
'DB_SQL_BUILD_CACHE' => true,
'DB_SQL_BUILD_LENGTH' => 20, // SQL缓存的队列长度
'DATA_CACHE_PATH' => TEMP_PATH,

Die Abfrage-Cache-Funktion unterstützt alle Datenbanken und unterstützt alle Caching-Methoden und Gültigkeitszeiträume.

Bei Verwendung des Abfragecaches müssen Sie nur die Cache-Methode der Model-Klasse aufrufen, zum Beispiel:

$Model->cache(true)->select();

Wenn Cache(true) verwendet wird, wird das aktuelle Abfrage-SQL verarbeitet Beim Abfragen verwendet die Cache-Methode standardmäßig die durch den Parameter DATA_CACHE_TYPE festgelegte Cache-Methode (der Systemstandardwert ist File, was bedeutet, dass der Cache-Gültigkeitszeitraum die durch den Parameter DATA_CACHE_TIME festgelegte Zeit ist). . Die Cache-Methode und die Gültigkeitsdauer des Abfrage-Cache können auch separat angegeben werden:

$Model->cache(true,60,'xcache')->select();

gibt an, dass der aktuelle Abfrage-Cache-Cache-Modus xcache ist und die Cache-Gültigkeitsdauer 60 Sekunden beträgt.

Wenn für dieselbe Abfrage die Cache-Methode nicht verwendet wird, wird kein Cache abgerufen oder generiert, selbst wenn die Cache-Methode zuvor aufgerufen wurde.

Der Abfragecache ist nur für interne Aufrufe gedacht. Wenn Sie möchten, dass der Abfragecache für andere Programme geöffnet ist, können Sie den Schlüssel des Abfragecaches angeben. Zum Beispiel:

$Model->cache('cache_name',60)->select();

Das ist möglich Rufen Sie den Abfrage-Cache direkt extern über die S-Methode ab.

$value = S('cache_name');

Zusätzlich zur Select-Methode unterstützt der Abfrage-Cache auch die Methoden find und getField sowie deren abgeleitete Methoden (einschließlich statistischer Abfragen und dynamischer Methoden). Abfragemethoden). Für bestimmte Anwendungen können Sie die Caching-Methode und die Cache-Gültigkeitsdauer entsprechend Ihren Anforderungen auswählen.

SQL-Parsing-Cache

Zusätzlich zum Abfrage-Caching unterstützt ThinkPHP auch das SQL-Parsing-Caching. Aufgrund des ORM-Mechanismus von ThinkPHP wird das gesamte SQL dynamisch generiert und dann ausgeführt Datenbanktreiber.

Wenn Ihre Anwendung also viele SQL-Abfrageanforderungen hat, können Sie den SQL-Parsing-Cache aktivieren, um die SQL-Analyse zu reduzieren und die Leistung zu verbessern. Um das SQL-Parsing-Caching zu aktivieren, müssen Sie nur Folgendes festlegen:

'DB_SQL_BUILD_CACHE' => true,

, um den SQL-Erstellungscache für Datenbankabfragen zu aktivieren. Es unterstützt auch xcache und apc-Caching :

'DB_SQL_BUILD_QUEUE' => 'xcache',

Wir wissen, dass die Menge an SQL-Abfragen für ein Projekt sehr groß sein kann, daher ist es notwendig, die Länge der Cache-Warteschlange festzulegen. Wenn wir beispielsweise hoffen, dass der SQL-Analyse-Cache 20 nicht überschreitet Datensätze können wir festlegen:

'DB_SQL_BUILD_LENGTH' => 20, // SQL缓存的队列长度

Hinweis: Nur die Abfragemethode unterstützt SQL-Parsing-Cache

Statischer Cache

Um die statische Cache-Funktion zu verwenden, Sie müssen den Parameter HTML_CACHE_ON aktivieren und den Konfigurationsparameter HTML_CACHE_RULES verwenden, um die Cache-Regeldatei für den statischen Cache festzulegen.

Obwohl statische Caching-Regeln auch in der Anwendungskonfigurationsdatei definiert werden können, wird empfohlen, statische Caching-Regeln für verschiedene Module in der Modulkonfigurationsdatei zu definieren.

Statische Regeldefinition

Die Definition statischer Regeln lautet wie folgt:

'HTML_CACHE_ON' => true, // 开启静态缓存
'HTML_CACHE_TIME' => 60, // 全局静态缓存有效期（秒）
'HTML_FILE_SUFFIX' => '.shtml', // 设置静态缓存文件后缀
'HTML_CACHE_RULES' => array( // 定义静态缓存规则
 // 定义格式1 数组方式
 '静态地址' => array('静态规则', '有效期', '附加规则'), 
 // 定义格式2 字符串方式
 '静态地址' => '静态规则', 
)

Definitionsformat 1 verwendet ein Array, um das Festlegen verschiedener Einstellungen für a zu erleichtern Statische Regel. Der Gültigkeitszeitraum, Definitionsformat 2, verwendet den String-Modus, um statische Regeln zu abonnieren, und verwendet den durch HTML_CACHE_TIME festgelegten globalen Gültigkeitszeitraum für den statischen Cache.

静态缓存文件的根目录在HTML_PATH定义的路径下面，并且只有定义了静态规则的操作才会进行静态缓存。 并且静态缓存支持不同的存储类型。 静态缓存仅在GET请求下面有效。

静态地址

静态地址包括下面几种定义格式：

第一种是定义全局的操作静态规则，例如定义所有的read操作的静态规则为：

'read'=>array('{id}',60)

其中，{id}

表示取$_GET['id']

为静态缓存文件名，第二个参数表示缓存60秒。

第二种是定义全局的控制器静态规则，例如定义所有的User控制器的静态规则为：

'user:'=>array('User/{:action}_{id}','600')

其中，{:action}

表示当前的操作名称

第三种是定义某个控制器的操作的静态规则，例如，我们需要定义Blog控制器的read操作进行静态缓存

'blog:read'=>array('{id}',0)

第四种方式是定义全局的静态缓存规则，这个属于特殊情况下的使用，任何模块的操作都适用，例如：

'*'=>array('{$_SERVER.REQUEST_URI|md5}'),

表示根据当前的URL进行缓存。

静态规则

静态规则是用于定义要生成的静态文件的名称，静态规则的定义要确保不会冲突，写法可以包括以下情况：

1.使用系统变量

包括 _GET、_REQUEST、_SERVER、_SESSION、_COOKIE

格式：

{$_×××|function}

例如：

{$_GET.name} 
{$_SERVER.REQUEST_URI|md5}

2.使用框架特定的变量

{:module} 、{:controller} 和{:action}

分别表示当前模块名、控制器名和操作名。

例如：

{:module}/{:controller}_{:action}

3.使用_GET变量

{var|function}也就是说 {id}其实等效于 {$_GET.id}

4.直接使用函数

{|function} 例如：{|time}

5.支持混合定义

例如我们可以定义一个静态规则为：

'{id},{name|md5}'

在{}之外的字符作为字符串对待，如果包含有"/"，会自动创建目录。

例如，定义下面的静态规则：

{:module}/{:action}_{id}

则会在静态目录下面创建模块名称的子目录，然后写入操作名_id.shtml 文件。

静态缓存有效期

单位为秒。如果不定义，则会获取配置参数HTML_CACHE_TIME的设置值，如果定义为0则表示永久缓存。

附加规则

通常用于对静态规则进行函数运算，例如：

'read'=>array('Think{id},{name}','60', 'md5')

翻译后的静态规则是

md5('Think'.$_GET['id']. ', '.$_GET['name']);

Das obige ist der detaillierte Inhalt vonWelche Cache-Typen gibt es bei thinkphp?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!